sneakoscope 1.18.0 → 1.18.1

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.0** adds Universal Source Intelligence for Context7 + Codex Web Search, optional X AI MCP search when configured, main no-Scout / worker Scout-limited proof policy, per-agent terminal close evidence, tmux right-lane cockpit manifests, Codex official Goal mode detection, and full P0-P4 release readiness tracking.
+SKS **1.18.1** adds Dynamic Agent Pool replenishment: `agents=5` now means keep up to five active worker slots running until the work queue drains, with immutable session generations, generation-aware terminal close reports, real/fake-tmux pane launch evidence, and Source Intelligence / Goal mode refs propagated to every generation.
 
 ```bash
 sks mad-sks plan --target-root <path> --json
@@ -612,7 +612,7 @@ npm run release:check
 npm run publish:dry
 ```
 
-`release:check` runs the 1.18.0 parallel P0-P4 closure DAG, writes a source digest stamp under `.sneakoscope/reports/`, then refreshes release readiness so publish commands can verify the same stamp. The DAG preserves the 1.17 baseline gates and adds Source Intelligence, X AI/Codex Web policy, Goal mode, main no-Scout, worker Scout-limited, agent terminal, tmux right-lane, visual consistency, release full-coverage, and priority closure checks. Broader live or historical gates remain explicit scripts such as `release:real-check`. Generate the human-readable registry with `sks features inventory --write-docs`. Plain `npm publish` uses the `latest` dist-tag. npm's `prepublishOnly` verifies the fresh release stamp instead of rerunning the full gate, and `prepack` only rebuilds `dist`; publish no longer repeats the expensive release suite during packaging. `npm run publish:dry` remains the explicit dry-run helper.
+`release:check` runs the 1.18.1 dynamic agent pool closure DAG, writes a source digest stamp under `.sneakoscope/reports/`, then refreshes release readiness so publish commands can verify the same stamp. The DAG preserves the 1.18 baseline gates and adds dynamic pool, backfill replenishment, scheduler proof, session generation, terminal generation, tmux real right-lane, dynamic cockpit, Source Intelligence propagation, and Goal mode propagation checks. Broader live or historical gates remain explicit scripts such as `release:real-check`. Generate the human-readable registry with `sks features inventory --write-docs`. Plain `npm publish` uses the `latest` dist-tag. npm's `prepublishOnly` verifies the fresh release stamp instead of rerunning the full gate, and `prepack` only rebuilds `dist`; publish no longer repeats the expensive release suite during packaging. `npm run publish:dry` remains the explicit dry-run helper.
 
 Version bumps are manual. Run `sks versioning bump` only when preparing release metadata; SKS will not create `.git/hooks/pre-commit` or auto-bump during ordinary commits.
 

package/crates/sks-core/Cargo.lock

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

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "1.18.0"
+version = "1.18.1"
 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.0"),
+        Some("--version") => println!("sks-rs 1.18.1"),
         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.0",
-  "source_digest": "9593cf876b0f0b49ffb7aaa5e2ca1017bd7fd1508892f92cffbfc7db58fbfef0",
-  "source_file_count": 1279,
-  "built_at_source_time": 1779716030404
+  "package_version": "1.18.1",
+  "source_digest": "6df40e82722a56a4df2efafa956011204d7a96fd218b43d19aa10672bbd0842c",
+  "source_file_count": 1312,
+  "built_at_source_time": 1779722031788
 }

package/dist/bin/sks.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const FAST_PACKAGE_VERSION = '1.18.0';
+const FAST_PACKAGE_VERSION = '1.18.1';
 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.0",
-  "package_version": "1.18.0",
+  "version": "1.18.1",
+  "package_version": "1.18.1",
   "typescript": true,
   "mjs_runtime_files": 0,
-  "compiled_file_count": 850,
-  "compiled_js_count": 425,
-  "compiled_dts_count": 425,
-  "source_digest": "9593cf876b0f0b49ffb7aaa5e2ca1017bd7fd1508892f92cffbfc7db58fbfef0",
-  "source_file_count": 1279,
-  "source_files_hash": "29895436992640147aab36792cd376edbed9adc6226480db074ef9e9b5104c13",
-  "source_list_hash": "29895436992640147aab36792cd376edbed9adc6226480db074ef9e9b5104c13",
+  "compiled_file_count": 858,
+  "compiled_js_count": 429,
+  "compiled_dts_count": 429,
+  "source_digest": "6df40e82722a56a4df2efafa956011204d7a96fd218b43d19aa10672bbd0842c",
+  "source_file_count": 1312,
+  "source_files_hash": "fbe2aa994acefbdab214a17074d539960fa99369b928c3679442019ace20e7c6",
+  "source_list_hash": "fbe2aa994acefbdab214a17074d539960fa99369b928c3679442019ace20e7c6",
   "src_mjs_runtime_files": 0,
   "dist_stamp_schema": "sks.dist-build-stamp.v1",
   "files": [
@@ -234,8 +234,12 @@
     "core/agents/agent-runner-process.js",
     "core/agents/agent-runner-tmux.d.ts",
     "core/agents/agent-runner-tmux.js",
+    "core/agents/agent-scheduler.d.ts",
+    "core/agents/agent-scheduler.js",
     "core/agents/agent-schema.d.ts",
     "core/agents/agent-schema.js",
+    "core/agents/agent-session-generation.d.ts",
+    "core/agents/agent-session-generation.js",
     "core/agents/agent-session-rows.d.ts",
     "core/agents/agent-session-rows.js",
     "core/agents/agent-task-slicer.d.ts",
@@ -246,8 +250,12 @@
     "core/agents/agent-trust-report.js",
     "core/agents/agent-work-partition.d.ts",
     "core/agents/agent-work-partition.js",
+    "core/agents/agent-work-queue.d.ts",
+    "core/agents/agent-work-queue.js",
     "core/agents/agent-worker-pipeline.d.ts",
     "core/agents/agent-worker-pipeline.js",
+    "core/agents/agent-worker-slot.d.ts",
+    "core/agents/agent-worker-slot.js",
     "core/agents/agent-wrongness.d.ts",
     "core/agents/agent-wrongness.js",
     "core/agents/route-collaboration-ledger.d.ts",

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

@@ -436,6 +436,28 @@ export declare function run(command: any, args?: any): Promise<void | {
                 lease_count: number;
                 blockers: string[];
             };
+            scheduler: {
+                schema: string;
+                ok: boolean;
+                state: import("../core/agents/agent-scheduler.js").AgentSchedulerState;
+                queue: import("../core/agents/agent-work-queue.js").AgentWorkQueue;
+                slots: import("../core/agents/agent-worker-slot.js").AgentWorkerSlot[];
+                results: any[];
+            };
+            source_intelligence: {
+                artifact: string;
+                ok: boolean;
+                mode: import("../core/source-intelligence/source-intelligence-policy.js").SourceIntelligenceMode;
+                cache_key: string;
+                proof_ok: boolean;
+            };
+            goal_mode: {
+                artifact: string;
+                ok: boolean;
+                mode: "official_goal_default" | "sks_goal_fallback";
+                official_goal_available: boolean;
+                default_enabled: boolean;
+            };
             results: any[];
             consensus: {
                 schema: string;
@@ -526,6 +548,11 @@ export declare function run(command: any, args?: any): Promise<void | {
                     all_sessions_closed: boolean;
                     terminal_sessions_closed: any;
                     terminal_close_report: string;
+                    target_active_slots: any;
+                    max_observed_active_slots: any;
+                    backfill_count: any;
+                    pending_queue_drained: any;
+                    generation_count: any;
                     tmux_attach_command: string | null;
                     tmux_lane_manifest: string;
                     output_schema_ok: boolean;
@@ -542,7 +569,7 @@ export declare function run(command: any, args?: any): Promise<void | {
                 generated_at: string;
                 records: {
                     schema: string;
-                    kind: "xai_available_not_used" | "context7_missing" | "codex_web_search_missing" | "recursion_attempt" | "lease_conflict" | "session_not_closed" | "terminal_missing" | "terminal_not_closed" | "schema_invalid_output" | "stale_heartbeat" | "legacy_multiagent_runtime_usage_attempt";
+                    kind: "xai_available_not_used" | "context7_missing" | "codex_web_search_missing" | "recursion_attempt" | "lease_conflict" | "session_not_closed" | "terminal_missing" | "terminal_not_closed" | "scheduler_starvation" | "session_generation_missing" | "schema_invalid_output" | "stale_heartbeat" | "legacy_multiagent_runtime_usage_attempt";
                     blocker: string;
                     created_at: string;
                     status: string;
@@ -564,9 +591,27 @@ export declare function run(command: any, args?: any): Promise<void | {
                 closed_session_count: number;
                 terminal_sessions_closed: boolean;
                 terminal_session_count: number;
+                terminal_generation_count: number;
+                terminal_close_report_count: number;
                 terminal_close_report: string;
+                session_generation_count: number;
+                all_generations_closed: boolean;
+                scheduler_state: string;
+                target_active_slots: any;
+                max_observed_active_slots: any;
+                pending_queue_drained: boolean;
+                backfill_count: any;
+                expected_backfill_count: any;
+                slot_count: any;
+                generation_count: number;
+                all_slots_closed_after_drain: boolean;
+                generated_work_item_count: any;
+                source_intelligence_generation_refs_ok: boolean;
+                goal_mode_generation_refs_ok: boolean;
                 tmux_lane_manifest: string;
                 tmux_lane_manifest_ok: boolean;
+                tmux_pane_launch_ledger: string;
+                tmux_pane_launch_count: number;
                 ledger_hash_chain_ok: boolean;
                 no_overlap_ok: boolean;
                 consensus_ok: boolean;

package/dist/commands/ppt.d.ts

@@ -288,6 +288,28 @@ export declare function run(command: any, args?: any): Promise<void | {
                 lease_count: number;
                 blockers: string[];
             };
+            scheduler: {
+                schema: string;
+                ok: boolean;
+                state: import("../core/agents/agent-scheduler.js").AgentSchedulerState;
+                queue: import("../core/agents/agent-work-queue.js").AgentWorkQueue;
+                slots: import("../core/agents/agent-worker-slot.js").AgentWorkerSlot[];
+                results: any[];
+            };
+            source_intelligence: {
+                artifact: string;
+                ok: boolean;
+                mode: import("../core/source-intelligence/source-intelligence-policy.js").SourceIntelligenceMode;
+                cache_key: string;
+                proof_ok: boolean;
+            };
+            goal_mode: {
+                artifact: string;
+                ok: boolean;
+                mode: "official_goal_default" | "sks_goal_fallback";
+                official_goal_available: boolean;
+                default_enabled: boolean;
+            };
             results: any[];
             consensus: {
                 schema: string;
@@ -378,6 +400,11 @@ export declare function run(command: any, args?: any): Promise<void | {
                     all_sessions_closed: boolean;
                     terminal_sessions_closed: any;
                     terminal_close_report: string;
+                    target_active_slots: any;
+                    max_observed_active_slots: any;
+                    backfill_count: any;
+                    pending_queue_drained: any;
+                    generation_count: any;
                     tmux_attach_command: string | null;
                     tmux_lane_manifest: string;
                     output_schema_ok: boolean;
@@ -394,7 +421,7 @@ export declare function run(command: any, args?: any): Promise<void | {
                 generated_at: string;
                 records: {
                     schema: string;
-                    kind: "xai_available_not_used" | "context7_missing" | "codex_web_search_missing" | "recursion_attempt" | "lease_conflict" | "session_not_closed" | "terminal_missing" | "terminal_not_closed" | "schema_invalid_output" | "stale_heartbeat" | "legacy_multiagent_runtime_usage_attempt";
+                    kind: "xai_available_not_used" | "context7_missing" | "codex_web_search_missing" | "recursion_attempt" | "lease_conflict" | "session_not_closed" | "terminal_missing" | "terminal_not_closed" | "scheduler_starvation" | "session_generation_missing" | "schema_invalid_output" | "stale_heartbeat" | "legacy_multiagent_runtime_usage_attempt";
                     blocker: string;
                     created_at: string;
                     status: string;
@@ -416,9 +443,27 @@ export declare function run(command: any, args?: any): Promise<void | {
                 closed_session_count: number;
                 terminal_sessions_closed: boolean;
                 terminal_session_count: number;
+                terminal_generation_count: number;
+                terminal_close_report_count: number;
                 terminal_close_report: string;
+                session_generation_count: number;
+                all_generations_closed: boolean;
+                scheduler_state: string;
+                target_active_slots: any;
+                max_observed_active_slots: any;
+                pending_queue_drained: boolean;
+                backfill_count: any;
+                expected_backfill_count: any;
+                slot_count: any;
+                generation_count: number;
+                all_slots_closed_after_drain: boolean;
+                generated_work_item_count: any;
+                source_intelligence_generation_refs_ok: boolean;
+                goal_mode_generation_refs_ok: boolean;
                 tmux_lane_manifest: string;
                 tmux_lane_manifest_ok: boolean;
+                tmux_pane_launch_ledger: string;
+                tmux_pane_launch_count: number;
                 ledger_hash_chain_ok: boolean;
                 no_overlap_ok: boolean;
                 consensus_ok: boolean;

package/dist/core/agents/agent-central-ledger.d.ts

@@ -17,6 +17,7 @@ export declare function initializeAgentCentralLedger(missionDir: string, input:
     partition?: any;
     route?: string;
     prompt?: string;
+    dynamicScheduler?: boolean;
 }): Promise<string>;
 export declare function appendAgentLedgerEvent(root: string, event: {
     agent_id: string;

package/dist/core/agents/agent-central-ledger.js

@@ -47,10 +47,11 @@ export function validateAgentLedgerWriteScope(input) {
     const mode = input.mode || 'write';
     const orchestrator = actor === 'orchestrator' || actor === 'parent_orchestrator';
     const sessionMatch = target.match(/^sessions\/([^/]+)\.json$/);
+    const generationSessionMatch = target.match(/^sessions\/([^/]+)\/gen-\d+\/agent-session-record\.json$/);
     const messageAppend = target === 'agent-messages.jsonl' && mode === 'append';
     const eventAppend = target === 'agent-events.jsonl' && mode === 'append';
     const handoffAppend = target === 'agent-handoffs.jsonl' && mode === 'append';
-    const ownSessionWrite = Boolean(sessionMatch && sessionMatch[1] === actor);
+    const ownSessionWrite = Boolean((sessionMatch && sessionMatch[1] === actor) || (generationSessionMatch && generationSessionMatch[1] === actor));
     const orchestratorOnly = AGENT_ORCHESTRATOR_ONLY_FILES.includes(target) || target === 'agent-sessions.json';
     if (orchestrator)
         return { ok: true, reason: 'orchestrator_write_allowed', actor_agent_id: actor, target_path: target, mode };
@@ -58,7 +59,7 @@ export function validateAgentLedgerWriteScope(input) {
         return { ok: true, reason: 'own_session_record_allowed', actor_agent_id: actor, target_path: target, mode };
     if (messageAppend || eventAppend || handoffAppend)
         return { ok: true, reason: 'central_append_allowed', actor_agent_id: actor, target_path: target, mode };
-    if (sessionMatch && sessionMatch[1] !== actor)
+    if ((sessionMatch && sessionMatch[1] !== actor) || (generationSessionMatch && generationSessionMatch[1] !== actor))
         return { ok: false, reason: 'agent_cannot_modify_other_session_record', actor_agent_id: actor, target_path: target, mode };
     if (orchestratorOnly)
         return { ok: false, reason: 'agent_cannot_modify_orchestrator_only_file', actor_agent_id: actor, target_path: target, mode };
@@ -71,7 +72,7 @@ export async function initializeAgentCentralLedger(missionDir, input) {
     await writeTextAtomic(path.join(root, 'agent-events.jsonl'), '');
     await writeTextAtomic(path.join(root, 'agent-messages.jsonl'), '');
     await writeTextAtomic(path.join(root, 'agent-handoffs.jsonl'), '');
-    const sessions = Object.fromEntries((input.roster.roster || []).map((agent) => [agent.id, {
+    const sessions = input.dynamicScheduler ? {} : Object.fromEntries((input.roster.roster || []).map((agent) => [agent.id, {
             agent_id: agent.id,
             session_id: agent.session_id,
             status: 'pending',

package/dist/core/agents/agent-codex-cockpit.d.ts

@@ -35,6 +35,13 @@ export interface AgentCodexCockpitState {
     goal_mode_status: string | null;
     terminal_session_status: string | null;
     tmux_attach_command: string | null;
+    target_active_slots: number | null;
+    active_slot_count: number | null;
+    pending_queue_count: number | null;
+    backfill_count: number | null;
+    scheduler_status: string | null;
+    worker_slots: Array<Record<string, unknown>>;
+    session_generations: Array<Record<string, unknown>>;
     blockers: string[];
     agents: Array<Record<string, unknown>>;
     recent_events: string[];

package/dist/core/agents/agent-codex-cockpit.js

@@ -37,6 +37,9 @@ export async function buildAgentCodexCockpitState(missionDir, opts = {}) {
     const sourceIntelligence = await readJson(path.join(missionDir, 'source-intelligence-evidence.json'), null);
     const goalMode = await readJson(path.join(missionDir, 'goal-mode-applied.json'), null);
     const tmuxLayout = await readJson(path.join(root, 'agent-tmux-layout.json'), null);
+    const scheduler = await readJson(path.join(root, 'agent-scheduler-state.json'), null);
+    const workerSlots = await readJson(path.join(root, 'agent-worker-slots.json'), null);
+    const generations = await readJson(path.join(root, 'agent-session-generations.json'), null);
     const terminalClosed = proof?.terminal_sessions_closed === true;
     const eventsTail = await readTailLines(path.join(root, 'agent-events.jsonl'), 8);
     const cockpitEventsTail = await readTailLines(path.join(root, AGENT_CODEX_COCKPIT_EVENTS), 8);
@@ -68,6 +71,13 @@ export async function buildAgentCodexCockpitState(missionDir, opts = {}) {
         goal_mode_status: goalMode?.mode || null,
         terminal_session_status: terminalClosed ? 'closed' : proof ? 'blocked_or_unverified' : null,
         tmux_attach_command: tmuxLayout?.attach_command || null,
+        target_active_slots: scheduler?.target_active_slots ?? null,
+        active_slot_count: scheduler?.active_slot_count ?? null,
+        pending_queue_count: scheduler?.pending_count ?? null,
+        backfill_count: scheduler?.backfill_count ?? null,
+        scheduler_status: scheduler?.status || null,
+        worker_slots: Array.isArray(workerSlots?.slots) ? workerSlots.slots : [],
+        session_generations: generations?.generations ? Object.values(generations.generations) : [],
         blockers,
         agents,
         recent_events: [...eventsTail, ...cockpitEventsTail, ...teamTail].slice(-12),
@@ -98,6 +108,11 @@ export function renderAgentCodexDashboard(state) {
         `- Terminal sessions: ${state.terminal_session_status || 'unknown'}`,
         `- tmux attach: ${state.tmux_attach_command || 'unknown'}`,
         `- All sessions closed: ${state.all_sessions_closed ?? 'unknown'}`,
+        `- Scheduler: ${state.scheduler_status || 'unknown'}`,
+        `- Target active slots: ${state.target_active_slots ?? 'unknown'}`,
+        `- Active slots: ${state.active_slot_count ?? 'unknown'}`,
+        `- Pending queue: ${state.pending_queue_count ?? 'unknown'}`,
+        `- Backfill events: ${state.backfill_count ?? 'unknown'}`,
         '',
         '| Agent | Persona | Task | State | Heartbeat age | Lease | Blockers | Artifact |',
         '| --- | --- | --- | --- | --- | --- | --- | --- |',
@@ -116,6 +131,14 @@ export function renderAgentCodexDashboard(state) {
     return `${[...header, ...rows].join('\n')}\n`;
 }
 export function renderAgentSessionCards(state) {
+    const slotBlocks = state.worker_slots.map((slot) => [
+        `## ${cell(slot.slot_id)}`,
+        '',
+        `- Status: ${cell(slot.status)}`,
+        `- Current generation: ${cell(slot.current_generation_index)}`,
+        `- Current session: ${cell(slot.current_session_id)}`,
+        `- Generation count: ${cell(slot.generation_count)}`,
+    ].join('\n'));
     const blocks = state.agents.map((agent) => [
         `## ${cell(agent.id)}`,
         '',
@@ -125,7 +148,7 @@ export function renderAgentSessionCards(state) {
         `- Lease: ${cell(agent.lease || agent.lease_id || agent.write_policy)}`,
         `- Artifact: ${cell(agent.output_artifact || agent.artifact || '')}`,
     ].join('\n'));
-    return `# Agent Session Cards\n\n${blocks.join('\n\n')}\n`;
+    return `# Agent Session Cards\n\n${[...slotBlocks, ...blocks].join('\n\n')}\n`;
 }
 export function renderAgentProgressTimeline(state) {
     return `# Agent Progress Timeline\n\n${state.recent_events.map((line) => `- ${line}`).join('\n')}\n`;
@@ -140,6 +163,13 @@ function summarizeLiveState(state) {
         agent_count: state.agent_count,
         concurrency: state.concurrency,
         active_agents: state.agents.filter((agent) => !['closed', 'done', 'completed'].includes(String(agent.status || ''))).length,
+        target_active_slots: state.target_active_slots,
+        active_slot_count: state.active_slot_count,
+        pending_queue_count: state.pending_queue_count,
+        backfill_count: state.backfill_count,
+        scheduler_status: state.scheduler_status,
+        worker_slot_count: state.worker_slots.length,
+        session_generation_count: state.session_generations.length,
         proof_status: state.proof_status,
         source_intelligence_status: state.source_intelligence_status,
         xai_status: state.xai_status,

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

@@ -7,6 +7,9 @@ export interface AgentJanitorReport {
     stale_heartbeat_sessions: string[];
     zombie_process_sessions: string[];
     stale_tmux_sessions: string[];
+    active_generation_sessions: string[];
+    orphan_generation_dirs: string[];
+    slot_generation_cleanup: string[];
     orphan_temp_dirs: string[];
     stale_locks: string[];
     cleaned: string[];

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

@@ -9,6 +9,11 @@ export async function runAgentJanitor(input) {
     const namespace = await readJson(path.join(input.missionDir, 'project-session-namespace.json'), null);
     const projectHash = input.projectHash || namespace?.root_hash || null;
     const rows = normalizeAgentSessionRows(sessions);
+    const generations = await readJson(path.join(agentRoot, 'agent-session-generations.json'), null);
+    const generationRows = generations?.generations ? Object.values(generations.generations) : [];
+    const activeGenerationSessions = generationRows
+        .filter((row) => !row.closed_at && ['running', 'launching', 'collecting'].includes(String(row.status || 'running')))
+        .map((row) => String(row.session_id));
     const now = Date.now();
     const staleHeartbeat = rows
         .filter((row) => {
@@ -30,10 +35,15 @@ export async function runAgentJanitor(input) {
     }
     const zombieProcesses = await detectZombieProcessSessions(agentRoot, statusByAgent, statusBySession);
     const staleTmuxSessions = await detectStaleTmuxSessions(agentRoot, staleMs);
+    const orphanGenerationDirs = await detectOrphanGenerationDirs(agentRoot, new Set(generationRows.map((row) => String(row.artifact_dir || ''))));
     const orphanTempDirs = await scopedExistingPaths(Array.isArray(namespace?.orphan_temp_dirs) ? namespace.orphan_temp_dirs : [], projectHash);
     const staleLocks = await scopedStaleLockPaths(namespace?.lock_dir ? [namespace.lock_dir] : [], projectHash, staleMs);
     const cleaned = [];
     if (input.cleanup) {
+        for (const dir of orphanGenerationDirs) {
+            await fsp.rm(path.join(agentRoot, dir), { recursive: true, force: true }).catch(() => { });
+            cleaned.push(path.join(agentRoot, dir));
+        }
         for (const dir of orphanTempDirs) {
             await fsp.rm(dir, { recursive: true, force: true }).catch(() => { });
             cleaned.push(dir);
@@ -54,6 +64,9 @@ export async function runAgentJanitor(input) {
         stale_heartbeat_sessions: staleHeartbeat,
         zombie_process_sessions: zombieProcesses,
         stale_tmux_sessions: staleTmuxSessions,
+        active_generation_sessions: activeGenerationSessions,
+        orphan_generation_dirs: orphanGenerationDirs,
+        slot_generation_cleanup: cleaned.filter((entry) => entry.includes(`${path.sep}sessions${path.sep}`)),
         orphan_temp_dirs: orphanTempDirs,
         stale_locks: staleLocks,
         cleaned,
@@ -62,6 +75,25 @@ export async function runAgentJanitor(input) {
     await writeAgentJanitorReport(input.missionDir, report);
     return report;
 }
+async function detectOrphanGenerationDirs(agentRoot, knownGenerationDirs) {
+    const sessionsDir = path.join(agentRoot, 'sessions');
+    const out = [];
+    if (!(await exists(sessionsDir)))
+        return out;
+    for (const slot of await fsp.readdir(sessionsDir, { withFileTypes: true }).catch(() => [])) {
+        if (!slot.isDirectory())
+            continue;
+        const slotDir = path.join(sessionsDir, slot.name);
+        for (const gen of await fsp.readdir(slotDir, { withFileTypes: true }).catch(() => [])) {
+            if (!gen.isDirectory() || !/^gen-\d+$/.test(gen.name))
+                continue;
+            const rel = path.join('sessions', slot.name, gen.name);
+            if (!knownGenerationDirs.has(rel))
+                out.push(rel);
+        }
+    }
+    return out;
+}
 export async function writeAgentJanitorReport(missionDir, report) {
     await writeJsonAtomic(path.join(missionDir, 'agents', 'agent-janitor-report.json'), report);
 }