sneakoscope 1.18.3 → 1.18.4

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.3** closes the route-truth Dynamic Worker Pool runtime: `agents=5` means five target active worker slots, while `--work-items N` controls the route work queue. Pending work backfills empty slots immediately, tmux lanes persist as worker-slot UI until scheduler drain, follow-up work items are schema-bound, and Agent/Team/Research/QA blackboxes now execute the actual route commands while proving task graph, work queue, scheduler, terminal, Source Intelligence, Goal, and tmux supervisor evidence.
+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.
 
 ```bash
 sks mad-sks plan --target-root <path> --json
@@ -23,6 +23,11 @@ sks agent run "release review" --agents 8 --work-items 16 --concurrency 4 --mock
 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:intelligent-work-graph
+npm run proof:fake-vs-real-policy
+npm run route:blackbox-realism
+npm run release:real-check
 npm run agent:backfill-route-blackbox
 npm run team:actual-route-backfill
 npm run release:readiness
@@ -58,6 +63,12 @@ Detailed release history lives in [CHANGELOG.md](CHANGELOG.md). Current release
 - Main no-Scout / worker Scout policy: [docs/main-no-scout-worker-scout-policy.md](docs/main-no-scout-worker-scout-policy.md)
 - Agent terminal lanes: [docs/agent-terminal-lanes.md](docs/agent-terminal-lanes.md)
 - tmux right-lane cockpit: [docs/tmux-right-lane-cockpit.md](docs/tmux-right-lane-cockpit.md)
+- Real tmux pane proof: [docs/real-tmux-pane-proof.md](docs/real-tmux-pane-proof.md)
+- Real Codex dynamic smoke: [docs/real-codex-dynamic-smoke.md](docs/real-codex-dynamic-smoke.md)
+- 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)
 - 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.3"
+version = "1.18.4"
 dependencies = [
  "serde_json",
 ]

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "1.18.3"
+version = "1.18.4"
 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.3"),
+        Some("--version") => println!("sks-rs 1.18.4"),
         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.3",
-  "source_digest": "5aefcff7c0119b0c22dc3ca2d50edd2dbd5f069ea1a9838cee14700f0ede28de",
-  "source_file_count": 1370,
-  "built_at_source_time": 1779767703495
+  "package_version": "1.18.4",
+  "source_digest": "33109bbaf2af23979db84be40e35c9d47e2b35618270ab31547bfda9b59f590f",
+  "source_file_count": 1405,
+  "built_at_source_time": 1779777408842
 }

package/dist/build-manifest.json

@@ -1,16 +1,16 @@
 {
   "schema": "sks.dist-build.v2",
-  "version": "1.18.3",
-  "package_version": "1.18.3",
+  "version": "1.18.4",
+  "package_version": "1.18.4",
   "typescript": true,
   "mjs_runtime_files": 0,
-  "compiled_file_count": 864,
-  "compiled_js_count": 432,
-  "compiled_dts_count": 432,
-  "source_digest": "5aefcff7c0119b0c22dc3ca2d50edd2dbd5f069ea1a9838cee14700f0ede28de",
-  "source_file_count": 1370,
-  "source_files_hash": "1807c675876cb62160e1f8e2fb69a846610ba2a34fa01154263805337a98c149",
-  "source_list_hash": "1807c675876cb62160e1f8e2fb69a846610ba2a34fa01154263805337a98c149",
+  "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",
   "src_mjs_runtime_files": 0,
   "dist_stamp_schema": "sks.dist-build-stamp.v1",
   "files": [
@@ -186,6 +186,8 @@
     "commands/wiki.js",
     "core/agents/agent-central-ledger.d.ts",
     "core/agents/agent-central-ledger.js",
+    "core/agents/agent-cleanup-executor.d.ts",
+    "core/agents/agent-cleanup-executor.js",
     "core/agents/agent-cleanup.d.ts",
     "core/agents/agent-cleanup.js",
     "core/agents/agent-codex-cockpit.d.ts",
@@ -262,12 +264,16 @@
     "core/agents/agent-worker-slot.js",
     "core/agents/agent-wrongness.d.ts",
     "core/agents/agent-wrongness.js",
+    "core/agents/intelligent-work-graph.d.ts",
+    "core/agents/intelligent-work-graph.js",
     "core/agents/route-collaboration-ledger.d.ts",
     "core/agents/route-collaboration-ledger.js",
     "core/agents/scout-policy.d.ts",
     "core/agents/scout-policy.js",
     "core/agents/tmux-lane-supervisor.d.ts",
     "core/agents/tmux-lane-supervisor.js",
+    "core/agents/tmux-physical-proof.d.ts",
+    "core/agents/tmux-physical-proof.js",
     "core/agents/tmux-right-lane-cockpit.d.ts",
     "core/agents/tmux-right-lane-cockpit.js",
     "core/agents/work-partition/conflict-detector.d.ts",
@@ -713,6 +719,8 @@
     "core/proof/command-ledger.js",
     "core/proof/evidence-collector.d.ts",
     "core/proof/evidence-collector.js",
+    "core/proof/fake-real-proof-policy.d.ts",
+    "core/proof/fake-real-proof-policy.js",
     "core/proof/file-change-ledger.d.ts",
     "core/proof/file-change-ledger.js",
     "core/proof/proof-reader.d.ts",

package/dist/cli/feature-commands.js

@@ -171,18 +171,29 @@ export async function hooksCommand(sub = 'explain', args = []) {
                 return;
             }
         }
-        const report = await installManagedCodexHooks(root);
+        const projectReport = await installManagedCodexHooks(root);
+        const userReport = await installManagedCodexHooks(root, {
+            requirementsPath: path.join(os.homedir(), '.codex', 'requirements.toml'),
+            managedDir: path.join(os.homedir(), '.codex', 'managed-hooks')
+        });
+        const actual = await codexHookTrustDoctor(root, { actual: true });
         const result = {
-            ...report,
             schema: 'sks.codex-hooks-repair.v1',
+            ok: Boolean(projectReport.ok && userReport.ok && actual.ok),
             mode: 'managed',
+            root,
+            project_install: projectReport,
+            user_install: userReport,
+            actual_trust: actual.trust,
+            managed_dirs: actual.managed_dirs || [],
+            blockers: actual.blockers || [],
             next_command: 'sks hooks trust-doctor --actual --json',
-            actions: ['requirements_toml_managed_install_default']
+            actions: ['project_requirements_toml_managed_install', 'user_requirements_toml_managed_install']
         };
         if (flag(args, '--json'))
             return console.log(JSON.stringify(result, null, 2));
-        console.log(`Hooks managed repair: ${report.ok ? 'ok' : 'blocked'}`);
-        if (!report.ok)
+        console.log(`Hooks managed repair: ${result.ok ? 'ok' : 'blocked'}`);
+        if (!result.ok)
             process.exitCode = 1;
         return;
     }

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

@@ -438,14 +438,9 @@ export declare function run(command: any, args?: any): Promise<void | {
                 lease_count: number;
                 blockers: string[];
             };
-            task_graph: {
-                target_active_slots: number;
-                total_work_items: number;
-                generated_from_route: string;
-                work_items_exceed_active_slots: boolean;
-            };
+            task_graph: any;
             requested_work_items: number;
-            actual_total_work_items: number;
+            actual_total_work_items: any;
             target_active_slots: number;
             minimum_work_items: number;
             scheduler: {
@@ -578,6 +573,26 @@ export declare function run(command: any, args?: any): Promise<void | {
                         pane_survival_checked: boolean;
                         unexpected_close_count: number;
                         lane_count: number;
+                        physical_tmux_verified: boolean;
+                        physical_proof_status: any;
+                        list_panes_artifact: any;
+                        capture_pane_artifacts: any;
+                    };
+                    cleanup_executor: {
+                        status: string;
+                        proof: string | null;
+                        stale_processes_killed: any;
+                        stale_tmux_panes_closed: any;
+                        orphan_temp_dirs_removed: any;
+                        stale_locks_removed: any;
+                        skipped_active_sessions: any;
+                    };
+                    intelligent_work_graph: {
+                        status: string;
+                        score: any;
+                        test_ownership: string;
+                        critical_path: string;
+                        integration_bottlenecks: string;
                     };
                     output_schema_ok: boolean;
                     output_tail_report: string;
@@ -660,6 +675,25 @@ export declare function run(command: any, args?: any): Promise<void | {
                 tmux_lane_auto_reopen_count: number;
                 tmux_pane_launch_ledger: string;
                 tmux_pane_launch_count: number;
+                physical_tmux_verified: boolean;
+                tmux_physical_proof: string;
+                tmux_list_panes_artifact: any;
+                tmux_capture_pane_artifacts: any;
+                tmux_pane_id_reconciled: boolean;
+                real_truth_summary: {
+                    fake_backend: boolean;
+                    physical_tmux_verified: boolean;
+                    real_tmux_status: any;
+                    cleanup_executor_status: string;
+                    work_graph_quality_score: number;
+                    fake_vs_real_policy: string;
+                };
+                intelligent_work_graph: string;
+                test_ownership_map: string;
+                critical_path: string;
+                integration_bottlenecks: string;
+                work_graph_quality_score: number;
+                work_graph_quality_partial: boolean;
                 terminal_reports_match_generations: boolean;
                 ledger_hash_chain_ok: boolean;
                 no_overlap_ok: boolean;

package/dist/commands/ppt.d.ts

@@ -290,14 +290,9 @@ export declare function run(command: any, args?: any): Promise<void | {
                 lease_count: number;
                 blockers: string[];
             };
-            task_graph: {
-                target_active_slots: number;
-                total_work_items: number;
-                generated_from_route: string;
-                work_items_exceed_active_slots: boolean;
-            };
+            task_graph: any;
             requested_work_items: number;
-            actual_total_work_items: number;
+            actual_total_work_items: any;
             target_active_slots: number;
             minimum_work_items: number;
             scheduler: {
@@ -430,6 +425,26 @@ export declare function run(command: any, args?: any): Promise<void | {
                         pane_survival_checked: boolean;
                         unexpected_close_count: number;
                         lane_count: number;
+                        physical_tmux_verified: boolean;
+                        physical_proof_status: any;
+                        list_panes_artifact: any;
+                        capture_pane_artifacts: any;
+                    };
+                    cleanup_executor: {
+                        status: string;
+                        proof: string | null;
+                        stale_processes_killed: any;
+                        stale_tmux_panes_closed: any;
+                        orphan_temp_dirs_removed: any;
+                        stale_locks_removed: any;
+                        skipped_active_sessions: any;
+                    };
+                    intelligent_work_graph: {
+                        status: string;
+                        score: any;
+                        test_ownership: string;
+                        critical_path: string;
+                        integration_bottlenecks: string;
                     };
                     output_schema_ok: boolean;
                     output_tail_report: string;
@@ -512,6 +527,25 @@ export declare function run(command: any, args?: any): Promise<void | {
                 tmux_lane_auto_reopen_count: number;
                 tmux_pane_launch_ledger: string;
                 tmux_pane_launch_count: number;
+                physical_tmux_verified: boolean;
+                tmux_physical_proof: string;
+                tmux_list_panes_artifact: any;
+                tmux_capture_pane_artifacts: any;
+                tmux_pane_id_reconciled: boolean;
+                real_truth_summary: {
+                    fake_backend: boolean;
+                    physical_tmux_verified: boolean;
+                    real_tmux_status: any;
+                    cleanup_executor_status: string;
+                    work_graph_quality_score: number;
+                    fake_vs_real_policy: string;
+                };
+                intelligent_work_graph: string;
+                test_ownership_map: string;
+                critical_path: string;
+                integration_bottlenecks: string;
+                work_graph_quality_score: number;
+                work_graph_quality_partial: boolean;
                 terminal_reports_match_generations: boolean;
                 ledger_hash_chain_ok: boolean;
                 no_overlap_ok: boolean;

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

@@ -0,0 +1,47 @@
+export declare const AGENT_CLEANUP_PROOF_SCHEMA = "sks.agent-cleanup-proof.v1";
+export declare const AGENT_CLEANUP_ACTION_LEDGER_SCHEMA = "sks.agent-cleanup-action-ledger.v1";
+export interface AgentCleanupExecutorOptions {
+    missionDir: string;
+    missionId?: string | null;
+    action?: 'cleanup' | 'close';
+    apply?: boolean;
+    dryRun?: boolean;
+    drain?: boolean;
+    staleMs?: number;
+}
+type CleanupActionKind = 'terminate_process' | 'close_tmux_pane' | 'remove_temp_dir' | 'remove_lock' | 'skip_active_session' | 'skip_foreign_namespace' | 'archive_transcript_keep';
+interface CleanupAction {
+    kind: CleanupActionKind;
+    target: string;
+    status: 'planned' | 'applied' | 'skipped' | 'failed';
+    reason: string;
+    error?: string;
+}
+export declare function runAgentCleanupExecutor(opts: AgentCleanupExecutorOptions): Promise<{
+    schema: string;
+    generated_at: string;
+    ok: boolean;
+    mission_id: string | null;
+    project_namespace: string | null;
+    action: string;
+    dry_run: boolean;
+    apply: boolean;
+    stale_processes_found: string[];
+    stale_processes_killed: string[];
+    stale_tmux_panes_found: string[];
+    stale_tmux_panes_closed: string[];
+    orphan_temp_dirs_found: string[];
+    orphan_temp_dirs_removed: string[];
+    stale_locks_found: string[];
+    stale_locks_removed: string[];
+    skipped_active_sessions: string[];
+    skipped_foreign_namespace: string[];
+    terminal_transcripts_preserved: string[];
+    action_count: number;
+    applied_count: number;
+    failed_count: number;
+    actions: CleanupAction[];
+    blockers: string[];
+}>;
+export {};
+//# sourceMappingURL=agent-cleanup-executor.d.ts.map

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

@@ -0,0 +1,211 @@
+import fsp from 'node:fs/promises';
+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_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) {
+    const agentRoot = path.join(opts.missionDir, 'agents');
+    const action = opts.action || 'cleanup';
+    const apply = opts.apply === true && opts.dryRun !== true;
+    if (action === 'close' && opts.drain === true)
+        await drainTmuxLaneSupervisor(agentRoot).catch(() => null);
+    const namespace = await readJson(path.join(opts.missionDir, 'project-session-namespace.json'), null);
+    const sessionsRaw = await readJson(path.join(agentRoot, 'agent-sessions.json'), { sessions: {} });
+    const sessions = normalizeAgentSessionRows(sessionsRaw);
+    const activeSessionIds = new Set(sessions
+        .filter((row) => !TERMINAL_STATUSES.has(String(row.status || row.lifecycle_state || '')))
+        .map((row) => String(row.session_id || row.id || row.agent_id || ''))
+        .filter(Boolean));
+    const now = Date.now();
+    const staleMs = opts.staleMs ?? 30 * 60 * 1000;
+    const actions = [];
+    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;
+        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),
+            reason: terminal ? 'terminal_session_process_alive' : 'stale_session_process',
+            apply,
+            run: async () => {
+                process.kill(pid, 'SIGTERM');
+            }
+        }));
+    }
+    const tmuxReports = await listNamedFiles(path.join(agentRoot, 'sessions'), 'agent-tmux-report.json');
+    for (const file of tmuxReports) {
+        const report = await readJson(file, null);
+        const paneId = String(report?.pane_id || '');
+        const sessionId = String(report?.session_id || '');
+        if (!validTmuxPaneId(paneId))
+            continue;
+        if (activeSessionIds.has(sessionId)) {
+            actions.push({ kind: 'skip_active_session', target: sessionId || paneId, status: 'skipped', reason: 'tmux_session_active' });
+            continue;
+        }
+        actions.push(await applyAction({
+            kind: 'close_tmux_pane',
+            target: paneId,
+            reason: 'stale_tmux_pane',
+            apply,
+            run: async () => {
+                const { runProcess } = await import('../fsx.js');
+                await runProcess('tmux', ['kill-pane', '-t', paneId], { timeoutMs: 3000, maxOutputBytes: 4096 });
+            }
+        }));
+    }
+    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' });
+            continue;
+        }
+        if (!(await exists(dir)))
+            continue;
+        actions.push(await applyAction({
+            kind: 'remove_temp_dir',
+            target: dir,
+            reason: 'orphan_temp_dir',
+            apply,
+            run: async () => fsp.rm(dir, { recursive: true, force: true })
+        }));
+    }
+    for (const lock of await staleLockFiles(String(namespace?.lock_dir || ''), projectHash, now, staleMs)) {
+        actions.push(await applyAction({
+            kind: 'remove_lock',
+            target: lock,
+            reason: 'stale_lock_file',
+            apply,
+            run: async () => fsp.rm(lock, { force: true })
+        }));
+    }
+    for (const transcript of await listNamedFiles(path.join(agentRoot, 'sessions'), 'agent-terminal-session.json')) {
+        actions.push({ kind: 'archive_transcript_keep', target: transcript, status: 'skipped', reason: 'terminal_transcripts_are_preserved' });
+    }
+    const proof = buildCleanupProof({
+        generatedAt: nowIso(),
+        missionId: opts.missionId || namespace?.mission_id || null,
+        projectNamespace: projectHash || null,
+        action,
+        apply,
+        dryRun: !apply,
+        actions,
+        activeSessionIds: [...activeSessionIds]
+    });
+    await writeJsonAtomic(path.join(agentRoot, 'agent-cleanup-proof.json'), proof);
+    await writeJsonAtomic(path.join(agentRoot, 'agent-command-cleanup.json'), {
+        schema: 'sks.agent-command-cleanup.v2',
+        ok: proof.ok,
+        mission_id: proof.mission_id,
+        action,
+        cleanup_executor: 'agent-cleanup-proof.json',
+        cleanup_action_ledger: 'agent-cleanup-action-ledger.jsonl',
+        applied: apply,
+        blockers: proof.blockers
+    });
+    for (const row of actions) {
+        await appendJsonl(path.join(agentRoot, 'agent-cleanup-action-ledger.jsonl'), {
+            schema: AGENT_CLEANUP_ACTION_LEDGER_SCHEMA,
+            generated_at: proof.generated_at,
+            action: row
+        });
+    }
+    return proof;
+}
+function buildCleanupProof(input) {
+    const byKind = (kind, status) => input.actions.filter((row) => row.kind === kind && (!status || row.status === status));
+    const failed = input.actions.filter((row) => row.status === 'failed');
+    return {
+        schema: AGENT_CLEANUP_PROOF_SCHEMA,
+        generated_at: input.generatedAt,
+        ok: failed.length === 0,
+        mission_id: input.missionId,
+        project_namespace: input.projectNamespace,
+        action: input.action,
+        dry_run: input.dryRun,
+        apply: input.apply,
+        stale_processes_found: byKind('terminate_process').map((row) => row.target),
+        stale_processes_killed: byKind('terminate_process', 'applied').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),
+        orphan_temp_dirs_removed: byKind('remove_temp_dir', 'applied').map((row) => row.target),
+        stale_locks_found: byKind('remove_lock').map((row) => row.target),
+        stale_locks_removed: byKind('remove_lock', 'applied').map((row) => row.target),
+        skipped_active_sessions: [...new Set([...input.activeSessionIds, ...byKind('skip_active_session').map((row) => row.target)])].filter(Boolean),
+        skipped_foreign_namespace: byKind('skip_foreign_namespace').map((row) => row.target),
+        terminal_transcripts_preserved: byKind('archive_transcript_keep').map((row) => row.target),
+        action_count: input.actions.length,
+        applied_count: input.actions.filter((row) => row.status === 'applied').length,
+        failed_count: failed.length,
+        actions: input.actions,
+        blockers: failed.map((row) => `cleanup_action_failed:${row.kind}:${row.target}`)
+    };
+}
+async function applyAction(input) {
+    if (!input.apply)
+        return { kind: input.kind, target: input.target, status: 'planned', reason: input.reason };
+    try {
+        await input.run();
+        return { kind: input.kind, target: input.target, status: 'applied', reason: input.reason };
+    }
+    catch (err) {
+        return { kind: input.kind, target: input.target, status: 'failed', reason: input.reason, error: err instanceof Error ? err.message : String(err) };
+    }
+}
+async function staleLockFiles(lockDir, projectHash, now, staleMs) {
+    const out = [];
+    if (!lockDir || !namespaceOwnsPath(lockDir, projectHash) || !(await exists(lockDir)))
+        return out;
+    for (const file of await listFiles(lockDir)) {
+        const stat = await fsp.stat(file).catch(() => null);
+        if (stat && now - stat.mtimeMs > staleMs)
+            out.push(file);
+    }
+    return out;
+}
+async function listNamedFiles(dir, name) {
+    return (await listFiles(dir)).filter((file) => path.basename(file) === name);
+}
+async function listFiles(dir) {
+    const out = [];
+    if (!(await exists(dir)))
+        return out;
+    for (const entry of await fsp.readdir(dir, { withFileTypes: true }).catch(() => [])) {
+        const file = path.join(dir, entry.name);
+        if (entry.isDirectory())
+            out.push(...await listFiles(file));
+        else if (entry.isFile())
+            out.push(file);
+    }
+    return out;
+}
+function namespaceOwnsPath(candidate, projectHash) {
+    return Boolean(candidate && (!projectHash || candidate.includes(projectHash)));
+}
+function processIsAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function validTmuxPaneId(value) {
+    return /^%\d+$/.test(value);
+}
+//# sourceMappingURL=agent-cleanup-executor.js.map

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

@@ -13,6 +13,9 @@ export declare function parseAgentCommandArgs(command: string, args?: string[]):
     mock: boolean;
     real: boolean;
     readonly: boolean;
+    apply: boolean;
+    dryRun: boolean;
+    drain: boolean;
     json: boolean;
     missionId: string;
     lane: string;

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

@@ -16,6 +16,9 @@ export function parseAgentCommandArgs(command, args = []) {
     const mock = hasFlag(args, '--mock') || backend === 'fake';
     const real = hasFlag(args, '--real');
     const readonly = hasFlag(args, '--readonly') || hasFlag(args, '--read-only');
+    const apply = hasFlag(args, '--apply');
+    const dryRun = hasFlag(args, '--dry-run') || hasFlag(args, '--dryrun');
+    const drain = hasFlag(args, '--drain');
     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 missionDefault = action === 'run' || action === 'spawn' || action === 'plan' ? '' : 'latest';
@@ -24,7 +27,7 @@ export function parseAgentCommandArgs(command, args = []) {
     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, json, missionId, lane, codexApp };
+    return { command, action, prompt, route, agents, targetActiveSlots, desiredWorkItemCount, minimumWorkItems, maxQueueExpansion, concurrency, backend, mock, real, readonly, apply, dryRun, drain, json, missionId, lane, codexApp };
 }
 function hasFlag(args, flag) {
     return args.includes(flag);