sneakoscope 1.18.4 → 1.18.5

package/README.md

@@ -10,7 +10,7 @@ SKS does not try to clone every other harness. It focuses on one thing: making C
 
 ## Current Release
 
-SKS **1.18.4** closes the runtime-truth gap left after the route-truth Dynamic Worker Pool work: real tmux mode now requires physical pane evidence from `tmux list-panes`, `tmux capture-pane`, pane-id reconciliation, and drain-close checks; real Codex dynamic smoke is opt-in through `SKS_TEST_REAL_DYNAMIC_AGENTS=1`; `sks agent close/cleanup` now writes executor proof for stale process, tmux, temp, and lock cleanup; and the task graph carries an intelligent work graph score, test ownership, critical path, and integration bottleneck artifacts. Fake fixture evidence remains useful for hermetic release gates, but it is explicitly separated from real runtime proof.
+SKS **1.18.5** wires the 1.18.4 real-proof tools into the runtime lifecycle: real tmux mode now writes before-drain, after-drain, and final physical pane proof artifacts; real Codex dynamic smoke validates output-schema/result-file/process cleanup and reports `fixture_instrumented_real` honestly; `sks agent close/cleanup` performs process-tree-aware SIGTERM/SIGKILL cleanup; and the task graph carries AST/import/test ownership, critical path, and runtime truth matrix evidence.
 
 ```bash
 sks mad-sks plan --target-root <path> --json
@@ -24,8 +24,12 @@ npm run source-intelligence:all-modes
 npm run agent:background-terminals
 npm run agent:tmux-lane-no-flicker
 npm run agent:cleanup-executor
+npm run agent:cleanup-executor-v2
 npm run agent:intelligent-work-graph
+npm run agent:ast-aware-work-graph
 npm run proof:fake-vs-real-policy
+npm run proof:fake-real-policy-v2
+npm run release:runtime-truth-matrix
 npm run route:blackbox-realism
 npm run release:real-check
 npm run agent:backfill-route-blackbox
@@ -68,7 +72,7 @@ Detailed release history lives in [CHANGELOG.md](CHANGELOG.md). Current release
 - Agent cleanup executor: [docs/agent-cleanup-executor.md](docs/agent-cleanup-executor.md)
 - Intelligent work graph: [docs/intelligent-work-graph.md](docs/intelligent-work-graph.md)
 - Fake vs real proof policy: [docs/fake-vs-real-proof-policy.md](docs/fake-vs-real-proof-policy.md)
-- Migration 1.18.3 to 1.18.4: [docs/migration-1.18.3-to-1.18.4.md](docs/migration-1.18.3-to-1.18.4.md)
+- Migration 1.18.4 to 1.18.5: [docs/migration-1.18.4-to-1.18.5.md](docs/migration-1.18.4-to-1.18.5.md)
 - Codex official Goal mode: [docs/codex-official-goal-mode.md](docs/codex-official-goal-mode.md)
 - Release parallel full coverage: [docs/release-parallel-full-coverage.md](docs/release-parallel-full-coverage.md)
 - Priority closure P0-P4: [docs/priority-closure-p0-p4.md](docs/priority-closure-p0-p4.md)

package/crates/sks-core/Cargo.lock

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

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "1.18.4"
+version = "1.18.5"
 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 1.18.4"),
+        Some("--version") => println!("sks-rs 1.18.5"),
         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": "1.18.4",
-  "source_digest": "33109bbaf2af23979db84be40e35c9d47e2b35618270ab31547bfda9b59f590f",
-  "source_file_count": 1405,
-  "built_at_source_time": 1779777408842
+  "package_version": "1.18.5",
+  "source_digest": "25698b68e8f9d6ff16ac94f404e60d99db9841e8e85a0f8c5831069a744434cc",
+  "source_file_count": 1430,
+  "built_at_source_time": 1779807721873
 }

package/dist/build-manifest.json

@@ -1,16 +1,16 @@
 {
   "schema": "sks.dist-build.v2",
-  "version": "1.18.4",
-  "package_version": "1.18.4",
+  "version": "1.18.5",
+  "package_version": "1.18.5",
   "typescript": true,
   "mjs_runtime_files": 0,
-  "compiled_file_count": 872,
-  "compiled_js_count": 436,
-  "compiled_dts_count": 436,
-  "source_digest": "33109bbaf2af23979db84be40e35c9d47e2b35618270ab31547bfda9b59f590f",
-  "source_file_count": 1405,
-  "source_files_hash": "eef20a281a31010636ae8b25a6e03acd3ac4564fb9870beed34653150250e3fe",
-  "source_list_hash": "eef20a281a31010636ae8b25a6e03acd3ac4564fb9870beed34653150250e3fe",
+  "compiled_file_count": 874,
+  "compiled_js_count": 437,
+  "compiled_dts_count": 437,
+  "source_digest": "25698b68e8f9d6ff16ac94f404e60d99db9841e8e85a0f8c5831069a744434cc",
+  "source_file_count": 1430,
+  "source_files_hash": "f8db0c06ebed73d7f4ee1f33117ef1dc633b59312f6d976ca6abf2e525d527fe",
+  "source_list_hash": "f8db0c06ebed73d7f4ee1f33117ef1dc633b59312f6d976ca6abf2e525d527fe",
   "src_mjs_runtime_files": 0,
   "dist_stamp_schema": "sks.dist-build-stamp.v1",
   "files": [
@@ -887,6 +887,8 @@
     "core/wiki-image/visual-anchor.js",
     "core/work-order-ledger.d.ts",
     "core/work-order-ledger.js",
+    "scripts/release-parallel-check.d.ts",
+    "scripts/release-parallel-check.js",
     "vendor/openai-codex/latest/hooks/permission-request.command.input.schema.json",
     "vendor/openai-codex/latest/hooks/permission-request.command.output.schema.json",
     "vendor/openai-codex/latest/hooks/post-compact.command.input.schema.json",

package/dist/commands/image-ux-review.d.ts

@@ -575,6 +575,10 @@ export declare function run(command: any, args?: any): Promise<void | {
                         lane_count: number;
                         physical_tmux_verified: boolean;
                         physical_proof_status: any;
+                        physical_proof_summary: string | null;
+                        before_drain_proof: string | null;
+                        after_drain_proof: string | null;
+                        final_proof: string | null;
                         list_panes_artifact: any;
                         capture_pane_artifacts: any;
                     };
@@ -601,6 +605,12 @@ export declare function run(command: any, args?: any): Promise<void | {
                     killed_timed_out_sessions: any;
                     fake_backend_disclaimer: string | null;
                 };
+                runtime_truth_groups: {
+                    Fake: string[];
+                    Optional: string[];
+                    Proven: string[];
+                    Blocked: string[];
+                };
                 blockers: any;
             };
             wrongness: {
@@ -677,6 +687,13 @@ export declare function run(command: any, args?: any): Promise<void | {
                 tmux_pane_launch_count: number;
                 physical_tmux_verified: boolean;
                 tmux_physical_proof: string;
+                tmux_physical_proof_summary: string;
+                tmux_physical_proof_before_drain: string;
+                tmux_physical_proof_after_drain: string;
+                tmux_physical_proof_final: string;
+                tmux_physical_before_drain_ok: boolean;
+                tmux_physical_after_drain_ok: boolean;
+                tmux_physical_final_ok: boolean;
                 tmux_list_panes_artifact: any;
                 tmux_capture_pane_artifacts: any;
                 tmux_pane_id_reconciled: boolean;

package/dist/commands/ppt.d.ts

@@ -427,6 +427,10 @@ export declare function run(command: any, args?: any): Promise<void | {
                         lane_count: number;
                         physical_tmux_verified: boolean;
                         physical_proof_status: any;
+                        physical_proof_summary: string | null;
+                        before_drain_proof: string | null;
+                        after_drain_proof: string | null;
+                        final_proof: string | null;
                         list_panes_artifact: any;
                         capture_pane_artifacts: any;
                     };
@@ -453,6 +457,12 @@ export declare function run(command: any, args?: any): Promise<void | {
                     killed_timed_out_sessions: any;
                     fake_backend_disclaimer: string | null;
                 };
+                runtime_truth_groups: {
+                    Fake: string[];
+                    Optional: string[];
+                    Proven: string[];
+                    Blocked: string[];
+                };
                 blockers: any;
             };
             wrongness: {
@@ -529,6 +539,13 @@ export declare function run(command: any, args?: any): Promise<void | {
                 tmux_pane_launch_count: number;
                 physical_tmux_verified: boolean;
                 tmux_physical_proof: string;
+                tmux_physical_proof_summary: string;
+                tmux_physical_proof_before_drain: string;
+                tmux_physical_proof_after_drain: string;
+                tmux_physical_proof_final: string;
+                tmux_physical_before_drain_ok: boolean;
+                tmux_physical_after_drain_ok: boolean;
+                tmux_physical_final_ok: boolean;
                 tmux_list_panes_artifact: any;
                 tmux_capture_pane_artifacts: any;
                 tmux_pane_id_reconciled: boolean;

package/dist/core/agents/agent-cleanup-executor.d.ts

@@ -1,4 +1,4 @@
-export declare const AGENT_CLEANUP_PROOF_SCHEMA = "sks.agent-cleanup-proof.v1";
+export declare const AGENT_CLEANUP_PROOF_SCHEMA = "sks.agent-cleanup-proof.v2";
 export declare const AGENT_CLEANUP_ACTION_LEDGER_SCHEMA = "sks.agent-cleanup-action-ledger.v1";
 export interface AgentCleanupExecutorOptions {
     missionDir: string;
@@ -16,6 +16,18 @@ interface CleanupAction {
     status: 'planned' | 'applied' | 'skipped' | 'failed';
     reason: string;
     error?: string;
+    process_tree?: ProcessTreeEntry[];
+    before?: Record<string, unknown>;
+    after?: Record<string, unknown>;
+    signal_sequence?: string[];
+    grace_ms?: number;
+    verified_exited?: boolean;
+    escalated_to_sigkill?: boolean;
+}
+interface ProcessTreeEntry {
+    pid: number;
+    ppid: number;
+    command: string;
 }
 export declare function runAgentCleanupExecutor(opts: AgentCleanupExecutorOptions): Promise<{
     schema: string;
@@ -28,6 +40,14 @@ export declare function runAgentCleanupExecutor(opts: AgentCleanupExecutorOption
     apply: boolean;
     stale_processes_found: string[];
     stale_processes_killed: string[];
+    process_trees: {
+        target: string;
+        tree: ProcessTreeEntry[];
+    }[];
+    sigterm_planned: string[];
+    sigterm_sent: string[];
+    sigkill_escalations: string[];
+    process_exit_verified: string[];
     stale_tmux_panes_found: string[];
     stale_tmux_panes_closed: string[];
     orphan_temp_dirs_found: string[];

package/dist/core/agents/agent-cleanup-executor.js

@@ -3,7 +3,7 @@ import path from 'node:path';
 import { appendJsonl, exists, nowIso, readJson, writeJsonAtomic } from '../fsx.js';
 import { drainTmuxLaneSupervisor } from './tmux-lane-supervisor.js';
 import { normalizeAgentSessionRows } from './agent-session-rows.js';
-export const AGENT_CLEANUP_PROOF_SCHEMA = 'sks.agent-cleanup-proof.v1';
+export const AGENT_CLEANUP_PROOF_SCHEMA = 'sks.agent-cleanup-proof.v2';
 export const AGENT_CLEANUP_ACTION_LEDGER_SCHEMA = 'sks.agent-cleanup-action-ledger.v1';
 const TERMINAL_STATUSES = new Set(['closed', 'completed', 'done', 'failed', 'blocked', 'killed', 'timed_out']);
 export async function runAgentCleanupExecutor(opts) {
@@ -21,28 +21,31 @@ export async function runAgentCleanupExecutor(opts) {
         .filter(Boolean));
     const now = Date.now();
     const staleMs = opts.staleMs ?? 30 * 60 * 1000;
+    const projectHash = String(namespace?.root_hash || '');
     const actions = [];
+    const graceMs = Number(process.env.SKS_CLEANUP_GRACE_MS || 750);
     const processReports = await listNamedFiles(path.join(agentRoot, 'sessions'), 'agent-process-report.json');
     for (const file of processReports) {
         const report = await readJson(file, null);
         const pid = Number(report?.pid || 0);
         const sessionId = String(report?.session_id || '');
         const status = String(sessions.find((row) => String(row.session_id || '') === sessionId)?.status || '');
-        const terminal = TERMINAL_STATUSES.has(status) || report?.exit_code !== null;
+        const terminal = TERMINAL_STATUSES.has(status) || (report?.exit_code !== null && report?.exit_code !== undefined);
         if (!pid || !processIsAlive(pid))
             continue;
         if (activeSessionIds.has(sessionId) && !terminal) {
             actions.push({ kind: 'skip_active_session', target: sessionId || String(pid), status: 'skipped', reason: 'session_active' });
             continue;
         }
-        actions.push(await applyAction({
-            kind: 'terminate_process',
-            target: String(pid),
+        if (!processReportInNamespace(report, projectHash)) {
+            actions.push({ kind: 'skip_foreign_namespace', target: String(pid), status: 'skipped', reason: 'process_outside_project_namespace' });
+            continue;
+        }
+        actions.push(await terminateProcessTreeAction({
+            pid,
             reason: terminal ? 'terminal_session_process_alive' : 'stale_session_process',
             apply,
-            run: async () => {
-                process.kill(pid, 'SIGTERM');
-            }
+            graceMs
         }));
     }
     const tmuxReports = await listNamedFiles(path.join(agentRoot, 'sessions'), 'agent-tmux-report.json');
@@ -64,10 +67,12 @@ export async function runAgentCleanupExecutor(opts) {
             run: async () => {
                 const { runProcess } = await import('../fsx.js');
                 await runProcess('tmux', ['kill-pane', '-t', paneId], { timeoutMs: 3000, maxOutputBytes: 4096 });
+                const listed = await runProcess('tmux', ['list-panes', '-a', '-F', '#{pane_id}'], { timeoutMs: 3000, maxOutputBytes: 4096 });
+                if (listed.stdout.split(/\r?\n/).includes(paneId))
+                    throw new Error('tmux_pane_still_listed_after_kill');
             }
         }));
     }
-    const projectHash = String(namespace?.root_hash || '');
     for (const dir of Array.isArray(namespace?.orphan_temp_dirs) ? namespace.orphan_temp_dirs.map(String) : []) {
         if (!namespaceOwnsPath(dir, projectHash)) {
             actions.push({ kind: 'skip_foreign_namespace', target: dir, status: 'skipped', reason: 'path_outside_project_namespace' });
@@ -139,6 +144,11 @@ function buildCleanupProof(input) {
         apply: input.apply,
         stale_processes_found: byKind('terminate_process').map((row) => row.target),
         stale_processes_killed: byKind('terminate_process', 'applied').map((row) => row.target),
+        process_trees: byKind('terminate_process').map((row) => ({ target: row.target, tree: row.process_tree || [] })),
+        sigterm_planned: input.actions.filter((row) => row.status === 'planned' && row.signal_sequence?.includes('SIGTERM')).map((row) => row.target),
+        sigterm_sent: input.actions.filter((row) => row.status === 'applied' && row.signal_sequence?.includes('SIGTERM')).map((row) => row.target),
+        sigkill_escalations: input.actions.filter((row) => row.escalated_to_sigkill === true).map((row) => row.target),
+        process_exit_verified: input.actions.filter((row) => row.kind === 'terminate_process' && row.verified_exited === true).map((row) => row.target),
         stale_tmux_panes_found: byKind('close_tmux_pane').map((row) => row.target),
         stale_tmux_panes_closed: byKind('close_tmux_pane', 'applied').map((row) => row.target),
         orphan_temp_dirs_found: byKind('remove_temp_dir').map((row) => row.target),
@@ -155,6 +165,72 @@ function buildCleanupProof(input) {
         blockers: failed.map((row) => `cleanup_action_failed:${row.kind}:${row.target}`)
     };
 }
+async function terminateProcessTreeAction(input) {
+    const processTree = await readProcessTree(input.pid);
+    const targets = processTree.length ? processTree.map((row) => row.pid) : [input.pid];
+    if (!input.apply) {
+        return {
+            kind: 'terminate_process',
+            target: String(input.pid),
+            status: 'planned',
+            reason: input.reason,
+            process_tree: processTree,
+            before: { alive: targets.filter(processIsAlive) },
+            after: { alive: targets.filter(processIsAlive) },
+            signal_sequence: ['SIGTERM', 'SIGKILL_IF_STILL_ALIVE'],
+            grace_ms: input.graceMs,
+            verified_exited: false,
+            escalated_to_sigkill: false
+        };
+    }
+    const signalSequence = [];
+    try {
+        for (const pid of [...targets].reverse())
+            safeKill(pid, 'SIGTERM');
+        signalSequence.push('SIGTERM');
+        await waitForProcessesExited(targets, input.graceMs);
+        let alive = targets.filter(processIsAlive);
+        let escalated = false;
+        if (alive.length) {
+            for (const pid of [...alive].reverse())
+                safeKill(pid, 'SIGKILL');
+            signalSequence.push('SIGKILL');
+            escalated = true;
+            await waitForProcessesExited(targets, 500);
+            alive = targets.filter(processIsAlive);
+        }
+        return {
+            kind: 'terminate_process',
+            target: String(input.pid),
+            status: alive.length ? 'failed' : 'applied',
+            reason: input.reason,
+            process_tree: processTree,
+            before: { alive: targets },
+            after: { alive },
+            signal_sequence: signalSequence,
+            grace_ms: input.graceMs,
+            verified_exited: alive.length === 0,
+            escalated_to_sigkill: escalated,
+            ...(alive.length ? { error: `processes_still_alive:${alive.join(',')}` } : {})
+        };
+    }
+    catch (err) {
+        return {
+            kind: 'terminate_process',
+            target: String(input.pid),
+            status: 'failed',
+            reason: input.reason,
+            process_tree: processTree,
+            before: { alive: targets },
+            after: { alive: targets.filter(processIsAlive) },
+            signal_sequence: signalSequence,
+            grace_ms: input.graceMs,
+            verified_exited: false,
+            escalated_to_sigkill: signalSequence.includes('SIGKILL'),
+            error: err instanceof Error ? err.message : String(err)
+        };
+    }
+}
 async function applyAction(input) {
     if (!input.apply)
         return { kind: input.kind, target: input.target, status: 'planned', reason: input.reason };
@@ -196,6 +272,19 @@ async function listFiles(dir) {
 function namespaceOwnsPath(candidate, projectHash) {
     return Boolean(candidate && (!projectHash || candidate.includes(projectHash)));
 }
+function processReportInNamespace(report, projectHash) {
+    if (!projectHash)
+        return true;
+    const raw = JSON.stringify({
+        project_hash: report?.project_hash,
+        root_hash: report?.root_hash,
+        project_namespace: report?.project_namespace,
+        cwd: report?.cwd,
+        stdout_log: report?.stdout_log,
+        stderr_log: report?.stderr_log
+    });
+    return raw === '{}' || raw.includes(projectHash) || (!report?.project_hash && !report?.root_hash && !report?.project_namespace);
+}
 function processIsAlive(pid) {
     try {
         process.kill(pid, 0);
@@ -205,6 +294,49 @@ function processIsAlive(pid) {
         return false;
     }
 }
+async function readProcessTree(rootPid) {
+    try {
+        const { runProcess } = await import('../fsx.js');
+        const result = await runProcess('ps', ['-axo', 'pid=,ppid=,command='], { timeoutMs: 3000, maxOutputBytes: 512 * 1024 });
+        const rows = result.stdout.split(/\r?\n/).map((line) => {
+            const match = line.match(/^\s*(\d+)\s+(\d+)\s+(.+)$/);
+            if (!match)
+                return null;
+            return { pid: Number(match[1]), ppid: Number(match[2]), command: match[3] || '' };
+        }).filter(Boolean);
+        const byParent = new Map();
+        for (const row of rows)
+            byParent.set(row.ppid, [...(byParent.get(row.ppid) || []), row]);
+        const out = [];
+        const visit = (pid) => {
+            const current = rows.find((row) => row.pid === pid);
+            if (current && !out.some((row) => row.pid === current.pid))
+                out.push(current);
+            for (const child of byParent.get(pid) || [])
+                visit(child.pid);
+        };
+        visit(rootPid);
+        return out;
+    }
+    catch {
+        return processIsAlive(rootPid) ? [{ pid: rootPid, ppid: 0, command: 'unknown' }] : [];
+    }
+}
+function safeKill(pid, signal) {
+    try {
+        process.kill(pid, signal);
+    }
+    catch { }
+}
+async function waitForProcessesExited(pids, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (!pids.some(processIsAlive))
+            return true;
+        await new Promise((resolve) => setTimeout(resolve, 50));
+    }
+    return !pids.some(processIsAlive);
+}
 function validTmuxPaneId(value) {
     return /^%\d+$/.test(value);
 }

package/dist/core/agents/agent-command-surface.d.ts

@@ -16,6 +16,7 @@ export declare function parseAgentCommandArgs(command: string, args?: string[]):
     apply: boolean;
     dryRun: boolean;
     drain: boolean;
+    staleMs: number;
     json: boolean;
     missionId: string;
     lane: string;

package/dist/core/agents/agent-command-surface.js

@@ -19,15 +19,16 @@ export function parseAgentCommandArgs(command, args = []) {
     const apply = hasFlag(args, '--apply');
     const dryRun = hasFlag(args, '--dry-run') || hasFlag(args, '--dryrun');
     const drain = hasFlag(args, '--drain');
+    const staleMs = Number(readOption(args, '--stale-ms', 30 * 60 * 1000));
     const codexApp = hasFlag(args, '--codex-app');
-    const positionals = positionalArgs(rest, new Set(['--agents', '--target-active-slots', '--work-items', '--minimum-work-items', '--max-queue-expansion', '--concurrency', '--backend', '--route', '--mission', '--mission-id', '--agent', '--lane']));
+    const positionals = positionalArgs(rest, new Set(['--agents', '--target-active-slots', '--work-items', '--minimum-work-items', '--max-queue-expansion', '--concurrency', '--backend', '--route', '--mission', '--mission-id', '--agent', '--lane', '--stale-ms']));
     const missionDefault = action === 'run' || action === 'spawn' || action === 'plan' ? '' : 'latest';
     const positionalMission = action === 'run' || action === 'spawn' || action === 'plan' ? '' : (positionals[0] || '');
     const missionId = String(readOption(args, '--mission', readOption(args, '--mission-id', positionalMission || missionDefault)));
     const lane = String(readOption(args, '--agent', readOption(args, '--lane', '')));
     const promptPositionals = positionalMission ? positionals.slice(1) : positionals;
     const prompt = promptPositionals.join(' ').trim() || 'Native agent run';
-    return { command, action, prompt, route, agents, targetActiveSlots, desiredWorkItemCount, minimumWorkItems, maxQueueExpansion, concurrency, backend, mock, real, readonly, apply, dryRun, drain, json, missionId, lane, codexApp };
+    return { command, action, prompt, route, agents, targetActiveSlots, desiredWorkItemCount, minimumWorkItems, maxQueueExpansion, concurrency, backend, mock, real, readonly, apply, dryRun, drain, staleMs, json, missionId, lane, codexApp };
 }
 function hasFlag(args, flag) {
     return args.includes(flag);

package/dist/core/agents/agent-orchestrator.d.ts

@@ -194,6 +194,10 @@ export declare function runNativeAgentOrchestrator(opts?: AgentRunOptions): Prom
                 lane_count: number;
                 physical_tmux_verified: boolean;
                 physical_proof_status: any;
+                physical_proof_summary: string | null;
+                before_drain_proof: string | null;
+                after_drain_proof: string | null;
+                final_proof: string | null;
                 list_panes_artifact: any;
                 capture_pane_artifacts: any;
             };
@@ -220,6 +224,12 @@ export declare function runNativeAgentOrchestrator(opts?: AgentRunOptions): Prom
             killed_timed_out_sessions: any;
             fake_backend_disclaimer: string | null;
         };
+        runtime_truth_groups: {
+            Fake: string[];
+            Optional: string[];
+            Proven: string[];
+            Blocked: string[];
+        };
         blockers: any;
     };
     wrongness: {
@@ -296,6 +306,13 @@ export declare function runNativeAgentOrchestrator(opts?: AgentRunOptions): Prom
         tmux_pane_launch_count: number;
         physical_tmux_verified: boolean;
         tmux_physical_proof: string;
+        tmux_physical_proof_summary: string;
+        tmux_physical_proof_before_drain: string;
+        tmux_physical_proof_after_drain: string;
+        tmux_physical_proof_final: string;
+        tmux_physical_before_drain_ok: boolean;
+        tmux_physical_after_drain_ok: boolean;
+        tmux_physical_final_ok: boolean;
         tmux_list_panes_artifact: any;
         tmux_capture_pane_artifacts: any;
         tmux_pane_id_reconciled: boolean;

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

@@ -36,6 +36,8 @@ export async function runNativeAgentOrchestrator(opts = {}) {
     const routeCommand = String(opts.routeCommand || defaultRouteCommand(route));
     const routeBlackboxKind = String(opts.routeBlackboxKind || defaultRouteBlackboxKind(route));
     const backend = normalizeAgentBackend(opts.backend || (opts.mock ? 'fake' : 'codex-exec'));
+    const realTmux = backend === 'tmux' && opts.real === true;
+    const realTmuxProofRequired = realTmux && process.env.SKS_REQUIRE_REAL_TMUX === '1';
     const created = opts.missionId
         ? { id: opts.missionId, dir: missionDir(root, opts.missionId), mission: { id: opts.missionId, mode: 'agent', prompt } }
         : await createMission(root, { mode: 'agent', prompt });
@@ -87,7 +89,8 @@ export async function runNativeAgentOrchestrator(opts = {}) {
     await writeIntelligentWorkGraphArtifacts(ledgerRoot, partition.intelligent_work_graph);
     await writeScoutPolicyArtifact(ledgerRoot);
     await writeTmuxRightLaneCockpit(ledgerRoot, { missionId, sessionName: `sks-${missionId}`, agents: roster.roster });
-    await initializeTmuxLaneSupervisor(ledgerRoot, { missionId, sessionName: `sks-${missionId}`, targetActiveSlots, launchRealTmux: backend === 'tmux' && opts.real === true });
+    await initializeTmuxLaneSupervisor(ledgerRoot, { missionId, sessionName: `sks-${missionId}`, targetActiveSlots, launchRealTmux: realTmux });
+    await writeTmuxPhysicalProof(ledgerRoot, { missionId, realTmux, required: realTmuxProofRequired, phase: 'initial' });
     await writeAgentCodexCockpitArtifacts(dir, { missionId, projectHash: namespace.root_hash });
     await writeJsonAtomic(path.join(ledgerRoot, 'agent-no-overlap-proof.json'), partition.no_overlap_proof || { schema: 'sks.agent-no-overlap-proof.v1', ok: false, blockers: ['missing_no_overlap_proof'] });
     await writeAgentLifecyclePolicy(ledgerRoot);
@@ -188,12 +191,12 @@ export async function runNativeAgentOrchestrator(opts = {}) {
             }
             if (String(event.event_type) === 'scheduler_draining') {
                 await verifyTmuxLaneSurvival(ledgerRoot);
-                await writeTmuxPhysicalProof(ledgerRoot, { missionId, realTmux: backend === 'tmux' && opts.real === true, phase: 'before_drain' });
+                await writeTmuxPhysicalProof(ledgerRoot, { missionId, realTmux, required: realTmuxProofRequired, phase: 'before_drain' });
             }
             await updateTmuxLaneSupervisorFromSlots(ledgerRoot, { missionId, sessionName: `sks-${missionId}`, slots, state, event });
             if (String(event.event_type) === 'scheduler_drained') {
                 await drainTmuxLaneSupervisor(ledgerRoot);
-                await writeTmuxPhysicalProof(ledgerRoot, { missionId, realTmux: backend === 'tmux' && opts.real === true, phase: 'after_drain' });
+                await writeTmuxPhysicalProof(ledgerRoot, { missionId, realTmux, required: realTmuxProofRequired, phase: 'after_drain' });
             }
         }
     });
@@ -210,7 +213,7 @@ export async function runNativeAgentOrchestrator(opts = {}) {
     const finalPaneBySlot = await readTmuxPaneIdsBySlot(ledgerRoot);
     const finalTmuxSlots = scheduler.slots.map((slot) => ({ ...slot, pane_id: finalPaneBySlot.get(slot.slot_id) || null, launch_status: finalPaneBySlot.has(slot.slot_id) ? 'launched' : slot.status }));
     await writeTmuxRightLaneCockpit(ledgerRoot, { missionId, sessionName: `sks-${missionId}`, slots: finalTmuxSlots });
-    await writeTmuxPhysicalProof(ledgerRoot, { missionId, realTmux: backend === 'tmux' && opts.real === true, phase: 'after_drain' });
+    await writeTmuxPhysicalProof(ledgerRoot, { missionId, realTmux, required: realTmuxProofRequired, phase: 'final' });
     await compactAgentLedger(ledgerRoot);
     const cleanup = await writeAgentCleanupReport(ledgerRoot);
     const janitor = await runAgentJanitor({ missionDir: dir, missionId, projectHash: namespace.root_hash });

package/dist/core/agents/agent-output-validator.d.ts

@@ -161,6 +161,19 @@ export declare const AGENT_RESULT_RUNTIME_SCHEMA: {
                     };
                     readonly lease_requirements: {
                         readonly type: "array";
+                        readonly items: {
+                            readonly type: "object";
+                            readonly required: readonly ["kind", "path"];
+                            readonly properties: {
+                                readonly kind: {
+                                    readonly type: "string";
+                                };
+                                readonly path: {
+                                    readonly type: "string";
+                                };
+                            };
+                            readonly additionalProperties: false;
+                        };
                     };
                     readonly max_attempts: {
                         readonly type: "integer";

package/dist/core/agents/agent-output-validator.js

@@ -93,7 +93,18 @@ export const AGENT_RESULT_RUNTIME_SCHEMA = {
                     required_persona_category: { type: 'string', minLength: 1 },
                     priority: { type: 'integer', minimum: 0 },
                     dependencies: { type: 'array', items: { type: 'string' } },
-                    lease_requirements: { type: 'array' },
+                    lease_requirements: {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                            required: ['kind', 'path'],
+                            properties: {
+                                kind: { type: 'string' },
+                                path: { type: 'string' }
+                            },
+                            additionalProperties: false
+                        }
+                    },
                     max_attempts: { type: 'integer', minimum: 1 },
                     reason: { type: 'string', minLength: 1 },
                     source_agent_session_id: { type: 'string' }

package/dist/core/agents/agent-proof-evidence.d.ts

@@ -82,6 +82,13 @@ export declare function writeAgentProofEvidence(root: string, input: {
     tmux_pane_launch_count: number;
     physical_tmux_verified: boolean;
     tmux_physical_proof: string;
+    tmux_physical_proof_summary: string;
+    tmux_physical_proof_before_drain: string;
+    tmux_physical_proof_after_drain: string;
+    tmux_physical_proof_final: string;
+    tmux_physical_before_drain_ok: boolean;
+    tmux_physical_after_drain_ok: boolean;
+    tmux_physical_final_ok: boolean;
     tmux_list_panes_artifact: any;
     tmux_capture_pane_artifacts: any;
     tmux_pane_id_reconciled: boolean;

package/dist/core/agents/agent-proof-evidence.js

@@ -18,6 +18,10 @@ export async function writeAgentProofEvidence(root, input) {
     const scheduler = input.scheduler || await readJson(path.join(root, 'agent-scheduler-state.json'), null);
     const taskGraph = input.partition?.task_graph || await readJson(path.join(root, 'agent-task-graph.json'), null);
     const tmuxPhysicalProof = await readJson(path.join(root, 'agent-tmux-physical-proof.json'), null);
+    const tmuxPhysicalProofSummary = await readJson(path.join(root, 'agent-tmux-physical-proof-summary.json'), null);
+    const tmuxPhysicalBeforeDrain = await readJson(path.join(root, 'agent-tmux-physical-proof-before-drain.json'), null);
+    const tmuxPhysicalAfterDrain = await readJson(path.join(root, 'agent-tmux-physical-proof-after-drain.json'), null);
+    const tmuxPhysicalFinal = await readJson(path.join(root, 'agent-tmux-physical-proof-final.json'), null);
     const cleanupProof = await readJson(path.join(root, 'agent-cleanup-proof.json'), null);
     const intelligentWorkGraph = await readJson(path.join(root, 'agent-intelligent-work-graph.json'), null);
     const slots = await readJson(path.join(root, 'agent-worker-slots.json'), null);
@@ -81,6 +85,10 @@ export async function writeAgentProofEvidence(root, input) {
         ...(laneSupervisor && Number(laneSupervisor.unexpected_close_count || 0) > 0 ? ['tmux_lane_unexpected_close_before_drain'] : []),
         ...(laneSupervisor?.blockers || []),
         ...(input.backend === 'tmux' && tmuxPhysicalProof?.physical_tmux_verified !== true ? ['tmux_physical_pane_proof_missing'] : []),
+        ...(input.backend === 'tmux' && !tmuxPhysicalBeforeDrain ? ['tmux_physical_before_drain_proof_missing'] : []),
+        ...(input.backend === 'tmux' && !tmuxPhysicalAfterDrain ? ['tmux_physical_after_drain_proof_missing'] : []),
+        ...(input.backend === 'tmux' && !tmuxPhysicalFinal ? ['tmux_physical_final_proof_missing'] : []),
+        ...(input.backend === 'tmux' && Array.isArray(tmuxPhysicalProofSummary?.blockers) ? tmuxPhysicalProofSummary.blockers : []),
         ...(input.backend === 'tmux' && Array.isArray(tmuxPhysicalProof?.blockers) ? tmuxPhysicalProof.blockers : []),
         ...(input.backend === 'tmux' && tmuxLanes?.ok !== true ? ['tmux_right_lane_manifest_missing'] : []),
         ...(input.backend === 'tmux' && tmuxPaneLaunchCount === 0 ? ['tmux_pane_launch_evidence_missing'] : []),
@@ -155,6 +163,13 @@ export async function writeAgentProofEvidence(root, input) {
         tmux_pane_launch_count: tmuxPaneLaunchCount,
         physical_tmux_verified: tmuxPhysicalProof?.physical_tmux_verified === true,
         tmux_physical_proof: 'agent-tmux-physical-proof.json',
+        tmux_physical_proof_summary: 'agent-tmux-physical-proof-summary.json',
+        tmux_physical_proof_before_drain: 'agent-tmux-physical-proof-before-drain.json',
+        tmux_physical_proof_after_drain: 'agent-tmux-physical-proof-after-drain.json',
+        tmux_physical_proof_final: 'agent-tmux-physical-proof-final.json',
+        tmux_physical_before_drain_ok: tmuxPhysicalBeforeDrain?.ok === true,
+        tmux_physical_after_drain_ok: tmuxPhysicalAfterDrain?.ok === true,
+        tmux_physical_final_ok: tmuxPhysicalFinal?.ok === true,
         tmux_list_panes_artifact: tmuxPhysicalProof?.tmux_list_panes_artifact || null,
         tmux_capture_pane_artifacts: tmuxPhysicalProof?.tmux_capture_pane_artifacts || [],
         tmux_pane_id_reconciled: tmuxPhysicalProof?.tmux_pane_id_reconciled === true,