sneakoscope 1.18.4 → 1.18.6

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.6** closes the zero-gap runtime truth loop: proof policy now reports every runtime subsystem separately, trust reports surface those subsystem proof levels, runtime truth matrix evidence is generated from live release artifacts, cleanup verifies process/tree/tmux/temp/lock after-states, and MAD-SKS writes explicit Warp/tmux lane proof instead of implying UI visibility.
 
 ```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,9 @@ 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)
+- Runtime truth matrix: [docs/runtime-truth-matrix.md](docs/runtime-truth-matrix.md)
+- Warp MAD tmux lanes: [docs/warp-mad-tmux-lanes.md](docs/warp-mad-tmux-lanes.md)
+- Migration 1.18.5 to 1.18.6: [docs/migration-1.18.5-to-1.18.6.md](docs/migration-1.18.5-to-1.18.6.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.6"
 dependencies = [
  "serde_json",
 ]

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "1.18.4"
+version = "1.18.6"
 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.6"),
         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.6",
+  "source_digest": "d45147f0f01dfabdab71a2e03ea484173d6de7e64e58958d1b73d31f8719ae5c",
+  "source_file_count": 1435,
+  "built_at_source_time": 1779844415377
 }

package/dist/bin/sks.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const FAST_PACKAGE_VERSION = '1.18.3';
+const FAST_PACKAGE_VERSION = '1.18.6';
 const args = process.argv.slice(2);
 try {
     if (args[0] === '--version' || args[0] === '-v' || args[0] === 'version') {

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.6",
+  "package_version": "1.18.6",
   "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": 878,
+  "compiled_js_count": 439,
+  "compiled_dts_count": 439,
+  "source_digest": "d45147f0f01dfabdab71a2e03ea484173d6de7e64e58958d1b73d31f8719ae5c",
+  "source_file_count": 1435,
+  "source_files_hash": "d1b0087b824861574256c5a1f9af243009a1ac33006649d562e5905cba8b829d",
+  "source_list_hash": "d1b0087b824861574256c5a1f9af243009a1ac33006649d562e5905cba8b829d",
   "src_mjs_runtime_files": 0,
   "dist_stamp_schema": "sks.dist-build-stamp.v1",
   "files": [
@@ -598,6 +598,8 @@
     "core/mad-sks/guard-middleware.js",
     "core/mad-sks/immutable-harness-guard.d.ts",
     "core/mad-sks/immutable-harness-guard.js",
+    "core/mad-sks/mad-tmux-lane-proof.d.ts",
+    "core/mad-sks/mad-tmux-lane-proof.js",
     "core/mad-sks/permission-model.d.ts",
     "core/mad-sks/permission-model.js",
     "core/mad-sks/proof-evidence.d.ts",
@@ -743,6 +745,8 @@
     "core/proof/route-proof-gate.js",
     "core/proof/route-proof-policy.d.ts",
     "core/proof/route-proof-policy.js",
+    "core/proof/runtime-truth-matrix.d.ts",
+    "core/proof/runtime-truth-matrix.js",
     "core/proof/selftest-proof-fixtures.d.ts",
     "core/proof/selftest-proof-fixtures.js",
     "core/proof/validation.d.ts",
@@ -887,6 +891,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,15 @@ 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[];
+                };
+                runtime_truth_matrix: string | null;
+                proof_level_by_subsystem: any;
+                fake_real_policy: string | null;
                 blockers: any;
             };
             wrongness: {
@@ -677,6 +690,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,15 @@ 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[];
+                };
+                runtime_truth_matrix: string | null;
+                proof_level_by_subsystem: any;
+                fake_real_policy: string | null;
                 blockers: any;
             };
             wrongness: {
@@ -529,6 +542,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;
@@ -8,6 +8,8 @@ export interface AgentCleanupExecutorOptions {
     dryRun?: boolean;
     drain?: boolean;
     staleMs?: number;
+    graceMs?: number;
+    killEscalation?: boolean;
 }
 type CleanupActionKind = 'terminate_process' | 'close_tmux_pane' | 'remove_temp_dir' | 'remove_lock' | 'skip_active_session' | 'skip_foreign_namespace' | 'archive_transcript_keep';
 interface CleanupAction {
@@ -16,6 +18,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,8 +42,23 @@ export declare function runAgentCleanupExecutor(opts: AgentCleanupExecutorOption
     apply: boolean;
     stale_processes_found: string[];
     stale_processes_killed: string[];
+    process_trees: {
+        target: string;
+        tree: ProcessTreeEntry[];
+    }[];
+    process_tree_count: number;
+    sigterm_planned: string[];
+    sigterm_sent: string[];
+    sigkill_escalations: string[];
+    process_exit_verified: string[];
+    sigterm_count: number;
+    sigkill_count: number;
+    verified_exited_count: number;
+    failed_to_kill_count: number;
     stale_tmux_panes_found: string[];
     stale_tmux_panes_closed: string[];
+    tmux_panes_verified_closed: string[];
+    tmux_close_failures: string[];
     orphan_temp_dirs_found: string[];
     orphan_temp_dirs_removed: string[];
     stale_locks_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,33 @@ 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 = opts.graceMs ?? Number(process.env.SKS_CLEANUP_GRACE_MS || 750);
+    const killEscalation = opts.killEscalation !== false && process.env.SKS_CLEANUP_KILL_ESCALATION !== '0';
     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,
+            killEscalation
         }));
     }
     const tmuxReports = await listNamedFiles(path.join(agentRoot, 'sessions'), 'agent-tmux-report.json');
@@ -52,7 +57,11 @@ export async function runAgentCleanupExecutor(opts) {
         const sessionId = String(report?.session_id || '');
         if (!validTmuxPaneId(paneId))
             continue;
-        if (activeSessionIds.has(sessionId)) {
+        if (!processReportInNamespace(report, projectHash)) {
+            actions.push({ kind: 'skip_foreign_namespace', target: paneId, status: 'skipped', reason: 'tmux_pane_outside_project_namespace' });
+            continue;
+        }
+        if (activeSessionIds.has(sessionId) && opts.drain !== true) {
             actions.push({ kind: 'skip_active_session', target: sessionId || paneId, status: 'skipped', reason: 'tmux_session_active' });
             continue;
         }
@@ -61,13 +70,16 @@ export async function runAgentCleanupExecutor(opts) {
             target: paneId,
             reason: 'stale_tmux_pane',
             apply,
+            before: async () => ({ listed: await tmuxPaneListed(paneId), pane_id: paneId }),
+            after: async () => ({ listed: await tmuxPaneListed(paneId), pane_id: paneId }),
             run: async () => {
                 const { runProcess } = await import('../fsx.js');
                 await runProcess('tmux', ['kill-pane', '-t', paneId], { timeoutMs: 3000, maxOutputBytes: 4096 });
+                if (await tmuxPaneListed(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' });
@@ -80,7 +92,13 @@ export async function runAgentCleanupExecutor(opts) {
             target: dir,
             reason: 'orphan_temp_dir',
             apply,
-            run: async () => fsp.rm(dir, { recursive: true, force: true })
+            before: async () => ({ exists: await exists(dir) }),
+            after: async () => ({ exists: await exists(dir) }),
+            run: async () => {
+                await fsp.rm(dir, { recursive: true, force: true });
+                if (await exists(dir))
+                    throw new Error('temp_dir_still_exists_after_remove');
+            }
         }));
     }
     for (const lock of await staleLockFiles(String(namespace?.lock_dir || ''), projectHash, now, staleMs)) {
@@ -89,7 +107,13 @@ export async function runAgentCleanupExecutor(opts) {
             target: lock,
             reason: 'stale_lock_file',
             apply,
-            run: async () => fsp.rm(lock, { force: true })
+            before: async () => ({ exists: await exists(lock) }),
+            after: async () => ({ exists: await exists(lock) }),
+            run: async () => {
+                await fsp.rm(lock, { force: true });
+                if (await exists(lock))
+                    throw new Error('lock_file_still_exists_after_remove');
+            }
         }));
     }
     for (const transcript of await listNamedFiles(path.join(agentRoot, 'sessions'), 'agent-terminal-session.json')) {
@@ -139,8 +163,20 @@ 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 || [] })),
+        process_tree_count: byKind('terminate_process').filter((row) => (row.process_tree || []).length > 0).length,
+        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),
+        sigterm_count: input.actions.filter((row) => row.signal_sequence?.includes('SIGTERM')).length,
+        sigkill_count: input.actions.filter((row) => row.signal_sequence?.includes('SIGKILL')).length,
+        verified_exited_count: input.actions.filter((row) => row.kind === 'terminate_process' && row.verified_exited === true).length,
+        failed_to_kill_count: input.actions.filter((row) => row.kind === 'terminate_process' && row.status === 'failed').length,
         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),
+        tmux_panes_verified_closed: byKind('close_tmux_pane', 'applied').filter((row) => row.after?.listed === false).map((row) => row.target),
+        tmux_close_failures: byKind('close_tmux_pane', 'failed').map((row) => row.target),
         orphan_temp_dirs_found: byKind('remove_temp_dir').map((row) => row.target),
         orphan_temp_dirs_removed: byKind('remove_temp_dir', 'applied').map((row) => row.target),
         stale_locks_found: byKind('remove_lock').map((row) => row.target),
@@ -155,15 +191,84 @@ 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: input.killEscalation ? ['SIGTERM', 'SIGKILL_IF_STILL_ALIVE'] : ['SIGTERM'],
+            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 && input.killEscalation) {
+            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) {
+    const before = input.before ? await input.before().catch((err) => ({ error: err instanceof Error ? err.message : String(err) })) : undefined;
     if (!input.apply)
-        return { kind: input.kind, target: input.target, status: 'planned', reason: input.reason };
+        return { kind: input.kind, target: input.target, status: 'planned', reason: input.reason, ...(before ? { before, after: before } : {}) };
     try {
         await input.run();
-        return { kind: input.kind, target: input.target, status: 'applied', reason: input.reason };
+        const after = input.after ? await input.after().catch((err) => ({ error: err instanceof Error ? err.message : String(err) })) : undefined;
+        return { kind: input.kind, target: input.target, status: 'applied', reason: input.reason, ...(before ? { before } : {}), ...(after ? { after } : {}) };
     }
     catch (err) {
-        return { kind: input.kind, target: input.target, status: 'failed', reason: input.reason, error: err instanceof Error ? err.message : String(err) };
+        const after = input.after ? await input.after().catch((afterErr) => ({ error: afterErr instanceof Error ? afterErr.message : String(afterErr) })) : undefined;
+        return { kind: input.kind, target: input.target, status: 'failed', reason: input.reason, error: err instanceof Error ? err.message : String(err), ...(before ? { before } : {}), ...(after ? { after } : {}) };
     }
 }
 async function staleLockFiles(lockDir, projectHash, now, staleMs) {
@@ -196,6 +301,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,7 +323,60 @@ 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);
 }
+async function tmuxPaneListed(paneId) {
+    try {
+        const { runProcess } = await import('../fsx.js');
+        const listed = await runProcess('tmux', ['list-panes', '-a', '-F', '#{pane_id}'], { timeoutMs: 3000, maxOutputBytes: 4096 });
+        return listed.stdout.split(/\r?\n/).includes(paneId);
+    }
+    catch {
+        return false;
+    }
+}
 //# sourceMappingURL=agent-cleanup-executor.js.map

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

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

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

@@ -19,15 +19,18 @@ 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 graceMs = Number(readOption(args, '--grace-ms', 750));
+    const killEscalation = hasFlag(args, '--kill-escalation') || !hasFlag(args, '--no-kill-escalation');
     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', '--grace-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, graceMs, killEscalation, 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,15 @@ 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[];
+        };
+        runtime_truth_matrix: string | null;
+        proof_level_by_subsystem: any;
+        fake_real_policy: string | null;
         blockers: any;
     };
     wrongness: {
@@ -296,6 +309,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;