sneakoscope 1.18.2 → 1.18.3

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.2** completes the 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 route blackboxes prove replenishment with generation, terminal, Source Intelligence, and Goal evidence.
+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.
 
 ```bash
 sks mad-sks plan --target-root <path> --json
@@ -24,6 +24,7 @@ npm run source-intelligence:all-modes
 npm run agent:background-terminals
 npm run agent:tmux-lane-no-flicker
 npm run agent:backfill-route-blackbox
+npm run team:actual-route-backfill
 npm run release:readiness
 ```
 
@@ -613,7 +614,7 @@ npm run release:check
 npm run publish:dry
 ```
 
-`release:check` runs the 1.18.2 dynamic scheduler 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 task graph expansion, schema-bound follow-up work, Agent/Team/Research/QA route backfill blackboxes, scheduler proof hardening, persistent tmux lane persistence, no-flicker lane proof, session generation, terminal generation, 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.
+`release:check` runs the 1.18.3 route-truth dynamic scheduler 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 task graph expansion, schema-bound follow-up work, actual Agent/Team/Research/QA route backfill blackboxes, scheduler proof hardening, persistent tmux lane supervisor integration, no-flicker lane proof, session generation, terminal generation, 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.2"
+version = "1.18.3"
 dependencies = [
  "serde_json",
 ]

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "1.18.2"
+version = "1.18.3"
 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.2"),
+        Some("--version") => println!("sks-rs 1.18.3"),
         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.2",
-  "source_digest": "83db107971a9e8bec6aaca8f43bf8b49d936e5fc778ebd62121dea9b7fc228f5",
-  "source_file_count": 1349,
-  "built_at_source_time": 1779732183819
+  "package_version": "1.18.3",
+  "source_digest": "5aefcff7c0119b0c22dc3ca2d50edd2dbd5f069ea1a9838cee14700f0ede28de",
+  "source_file_count": 1370,
+  "built_at_source_time": 1779767703495
 }

package/dist/bin/sks.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const FAST_PACKAGE_VERSION = '1.18.2';
+const FAST_PACKAGE_VERSION = '1.18.3';
 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.2",
-  "package_version": "1.18.2",
+  "version": "1.18.3",
+  "package_version": "1.18.3",
   "typescript": true,
   "mjs_runtime_files": 0,
   "compiled_file_count": 864,
   "compiled_js_count": 432,
   "compiled_dts_count": 432,
-  "source_digest": "83db107971a9e8bec6aaca8f43bf8b49d936e5fc778ebd62121dea9b7fc228f5",
-  "source_file_count": 1349,
-  "source_files_hash": "fb0fc5d3cacbb13d3231fcf9d0566e1bad998e7bc8aeea7c7e4f10049e433c11",
-  "source_list_hash": "fb0fc5d3cacbb13d3231fcf9d0566e1bad998e7bc8aeea7c7e4f10049e433c11",
+  "source_digest": "5aefcff7c0119b0c22dc3ca2d50edd2dbd5f069ea1a9838cee14700f0ede28de",
+  "source_file_count": 1370,
+  "source_files_hash": "1807c675876cb62160e1f8e2fb69a846610ba2a34fa01154263805337a98c149",
+  "source_list_hash": "1807c675876cb62160e1f8e2fb69a846610ba2a34fa01154263805337a98c149",
   "src_mjs_runtime_files": 0,
   "dist_stamp_schema": "sks.dist-build-stamp.v1",
   "files": [

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

@@ -385,6 +385,8 @@ export declare function run(command: any, args?: any): Promise<void | {
             ok: boolean;
             mission_id: any;
             route: string;
+            route_command: string;
+            route_blackbox_kind: string;
             backend: "tmux" | "fake" | "process" | "codex-exec";
             ledger_root: string;
             roster: {
@@ -442,6 +444,10 @@ export declare function run(command: any, args?: any): Promise<void | {
                 generated_from_route: string;
                 work_items_exceed_active_slots: boolean;
             };
+            requested_work_items: number;
+            actual_total_work_items: number;
+            target_active_slots: number;
+            minimum_work_items: number;
             scheduler: {
                 schema: string;
                 ok: boolean;
@@ -600,6 +606,10 @@ export declare function run(command: any, args?: any): Promise<void | {
                 generated_at: string;
                 mission_id: string;
                 backend: string;
+                route: string;
+                route_command: string;
+                route_blackbox_kind: string;
+                real_route_command_used: boolean;
                 real_parallel_claim: boolean;
                 fake_backend_disclaimer: string | null;
                 agent_count: any;
@@ -615,26 +625,42 @@ export declare function run(command: any, args?: any): Promise<void | {
                 session_generation_count: number;
                 all_generations_closed: boolean;
                 scheduler_state: string;
-                target_active_slots: any;
+                target_active_slots: number;
+                requested_work_items: number;
+                actual_total_work_items: number;
+                minimum_work_items: number;
+                task_graph_total_work_items: number;
+                work_queue_total_work_items: number;
+                scheduler_total_work_items: number;
+                task_graph_matches_cli_options: boolean;
+                work_queue_matches_task_graph: boolean;
+                scheduler_matches_work_queue: boolean;
                 max_observed_active_slots: any;
                 pending_queue_drained: boolean;
                 backfill_count: any;
                 expected_backfill_count: any;
+                backfill_expected_for_route: boolean;
                 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;
+                task_graph_source_refs_ok: any;
+                task_graph_goal_refs_ok: any;
+                work_queue_source_refs_ok: any;
+                work_queue_goal_refs_ok: any;
                 tmux_lane_manifest: string;
                 tmux_lane_manifest_ok: boolean;
                 tmux_lane_supervisor: string;
+                lane_supervisor_integrated: boolean;
                 tmux_lane_no_flicker_verified: boolean;
                 tmux_lane_survival_checked: boolean;
                 tmux_lane_unexpected_close_count: number;
                 tmux_lane_auto_reopen_count: number;
                 tmux_pane_launch_ledger: string;
                 tmux_pane_launch_count: number;
+                terminal_reports_match_generations: boolean;
                 ledger_hash_chain_ok: boolean;
                 no_overlap_ok: boolean;
                 consensus_ok: boolean;

package/dist/commands/ppt.d.ts

@@ -237,6 +237,8 @@ export declare function run(command: any, args?: any): Promise<void | {
             ok: boolean;
             mission_id: any;
             route: string;
+            route_command: string;
+            route_blackbox_kind: string;
             backend: "tmux" | "fake" | "process" | "codex-exec";
             ledger_root: string;
             roster: {
@@ -294,6 +296,10 @@ export declare function run(command: any, args?: any): Promise<void | {
                 generated_from_route: string;
                 work_items_exceed_active_slots: boolean;
             };
+            requested_work_items: number;
+            actual_total_work_items: number;
+            target_active_slots: number;
+            minimum_work_items: number;
             scheduler: {
                 schema: string;
                 ok: boolean;
@@ -452,6 +458,10 @@ export declare function run(command: any, args?: any): Promise<void | {
                 generated_at: string;
                 mission_id: string;
                 backend: string;
+                route: string;
+                route_command: string;
+                route_blackbox_kind: string;
+                real_route_command_used: boolean;
                 real_parallel_claim: boolean;
                 fake_backend_disclaimer: string | null;
                 agent_count: any;
@@ -467,26 +477,42 @@ export declare function run(command: any, args?: any): Promise<void | {
                 session_generation_count: number;
                 all_generations_closed: boolean;
                 scheduler_state: string;
-                target_active_slots: any;
+                target_active_slots: number;
+                requested_work_items: number;
+                actual_total_work_items: number;
+                minimum_work_items: number;
+                task_graph_total_work_items: number;
+                work_queue_total_work_items: number;
+                scheduler_total_work_items: number;
+                task_graph_matches_cli_options: boolean;
+                work_queue_matches_task_graph: boolean;
+                scheduler_matches_work_queue: boolean;
                 max_observed_active_slots: any;
                 pending_queue_drained: boolean;
                 backfill_count: any;
                 expected_backfill_count: any;
+                backfill_expected_for_route: boolean;
                 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;
+                task_graph_source_refs_ok: any;
+                task_graph_goal_refs_ok: any;
+                work_queue_source_refs_ok: any;
+                work_queue_goal_refs_ok: any;
                 tmux_lane_manifest: string;
                 tmux_lane_manifest_ok: boolean;
                 tmux_lane_supervisor: string;
+                lane_supervisor_integrated: boolean;
                 tmux_lane_no_flicker_verified: boolean;
                 tmux_lane_survival_checked: boolean;
                 tmux_lane_unexpected_close_count: number;
                 tmux_lane_auto_reopen_count: number;
                 tmux_pane_launch_ledger: string;
                 tmux_pane_launch_count: number;
+                terminal_reports_match_generations: boolean;
                 ledger_hash_chain_ok: boolean;
                 no_overlap_ok: boolean;
                 consensus_ok: boolean;

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

@@ -4,6 +4,8 @@ export declare function runNativeAgentOrchestrator(opts?: AgentRunOptions): Prom
     ok: boolean;
     mission_id: any;
     route: string;
+    route_command: string;
+    route_blackbox_kind: string;
     backend: "tmux" | "fake" | "process" | "codex-exec";
     ledger_root: string;
     roster: {
@@ -61,6 +63,10 @@ export declare function runNativeAgentOrchestrator(opts?: AgentRunOptions): Prom
         generated_from_route: string;
         work_items_exceed_active_slots: boolean;
     };
+    requested_work_items: number;
+    actual_total_work_items: number;
+    target_active_slots: number;
+    minimum_work_items: number;
     scheduler: {
         schema: string;
         ok: boolean;
@@ -219,6 +225,10 @@ export declare function runNativeAgentOrchestrator(opts?: AgentRunOptions): Prom
         generated_at: string;
         mission_id: string;
         backend: string;
+        route: string;
+        route_command: string;
+        route_blackbox_kind: string;
+        real_route_command_used: boolean;
         real_parallel_claim: boolean;
         fake_backend_disclaimer: string | null;
         agent_count: any;
@@ -234,26 +244,42 @@ export declare function runNativeAgentOrchestrator(opts?: AgentRunOptions): Prom
         session_generation_count: number;
         all_generations_closed: boolean;
         scheduler_state: string;
-        target_active_slots: any;
+        target_active_slots: number;
+        requested_work_items: number;
+        actual_total_work_items: number;
+        minimum_work_items: number;
+        task_graph_total_work_items: number;
+        work_queue_total_work_items: number;
+        scheduler_total_work_items: number;
+        task_graph_matches_cli_options: boolean;
+        work_queue_matches_task_graph: boolean;
+        scheduler_matches_work_queue: boolean;
         max_observed_active_slots: any;
         pending_queue_drained: boolean;
         backfill_count: any;
         expected_backfill_count: any;
+        backfill_expected_for_route: boolean;
         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;
+        task_graph_source_refs_ok: any;
+        task_graph_goal_refs_ok: any;
+        work_queue_source_refs_ok: any;
+        work_queue_goal_refs_ok: any;
         tmux_lane_manifest: string;
         tmux_lane_manifest_ok: boolean;
         tmux_lane_supervisor: string;
+        lane_supervisor_integrated: boolean;
         tmux_lane_no_flicker_verified: boolean;
         tmux_lane_survival_checked: boolean;
         tmux_lane_unexpected_close_count: number;
         tmux_lane_auto_reopen_count: number;
         tmux_pane_launch_ledger: string;
         tmux_pane_launch_count: number;
+        terminal_reports_match_generations: boolean;
         ledger_hash_chain_ok: boolean;
         no_overlap_ok: boolean;
         consensus_ok: boolean;

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

@@ -31,6 +31,8 @@ export async function runNativeAgentOrchestrator(opts = {}) {
     const root = path.resolve(opts.root || process.cwd());
     const prompt = String(opts.prompt || 'Native agent run');
     const route = opts.route || '$Agent';
+    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 created = opts.missionId
         ? { id: opts.missionId, dir: missionDir(root, opts.missionId), mission: { id: opts.missionId, mode: 'agent', prompt } }
@@ -51,6 +53,7 @@ export async function runNativeAgentOrchestrator(opts = {}) {
     }));
     const targetActiveSlots = normalizeTargetActiveSlots(opts.targetActiveSlots ?? opts.agents ?? roster.agent_count);
     const desiredWorkItemCount = normalizeDesiredWorkItemCount(opts.desiredWorkItemCount, opts.minimumWorkItems, targetActiveSlots);
+    const minimumWorkItems = normalizeMinimumWorkItems(opts.minimumWorkItems, targetActiveSlots);
     const sourceIntelligence = await runSourceIntelligence({ root, missionDir: dir, route, query: prompt, offline: true, context7Available: true });
     const sourceIntelligenceRef = {
         artifact: 'source-intelligence-evidence.json',
@@ -72,7 +75,7 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         route,
         targetActiveSlots,
         desiredWorkItemCount,
-        ...(opts.minimumWorkItems === undefined ? {} : { minimumWorkItems: opts.minimumWorkItems }),
+        minimumWorkItems,
         sourceIntelligenceRefs: sourceIntelligenceRef,
         goalModeRef
     });
@@ -81,7 +84,7 @@ export async function runNativeAgentOrchestrator(opts = {}) {
     await writeAgentTaskGraph(ledgerRoot, partition.task_graph);
     await writeScoutPolicyArtifact(ledgerRoot);
     await writeTmuxRightLaneCockpit(ledgerRoot, { missionId, sessionName: `sks-${missionId}`, agents: roster.roster });
-    await initializeTmuxLaneSupervisor(ledgerRoot, { missionId, sessionName: `sks-${missionId}`, targetActiveSlots });
+    await initializeTmuxLaneSupervisor(ledgerRoot, { missionId, sessionName: `sks-${missionId}`, targetActiveSlots, launchRealTmux: backend === 'tmux' && opts.real === true });
     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);
@@ -95,12 +98,14 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         batch_count: 0,
         target_active_slots: targetActiveSlots,
         desired_work_items: desiredWorkItemCount,
+        minimum_work_items: minimumWorkItems,
+        requested_work_items: desiredWorkItemCount,
         total_work_items: partition.task_graph?.total_work_items || partition.slices.length,
         backpressure: 'dynamic scheduler maintains target active slots until the work queue drains',
         rate_limit_delay_ms: backend === 'codex-exec' ? 250 : 0,
         resource_pressure_warnings: roster.agent_count > roster.concurrency ? ['agents_exceed_concurrency_batches'] : []
     });
-    await setCurrent(root, { mission_id: missionId, mode: 'AGENT', phase: 'AGENT_NATIVE_KERNEL_RUNNING', route_command: 'sks agent', native_agent_backend: backend });
+    await setCurrent(root, { mission_id: missionId, mode: 'AGENT', phase: 'AGENT_NATIVE_KERNEL_RUNNING', route_command: routeCommand, native_agent_backend: backend });
     const scheduler = await runAgentScheduler({
         root: ledgerRoot,
         missionId,
@@ -210,7 +215,28 @@ export async function runNativeAgentOrchestrator(opts = {}) {
     ];
     const trust = await writeAgentTrustReport(ledgerRoot, { missionId, backend, roster, partition, cleanup, outputTails, timeoutKill, backendReport, outputValidation, scheduler: scheduler.state, blockers });
     const wrongness = await writeAgentWrongnessRecords(ledgerRoot, blockers);
-    const proof = await writeAgentProofEvidence(ledgerRoot, { missionId, backend, realParallel: backend === 'codex-exec' && opts.mock !== true, roster, partition, consensus, results, cleanup, janitor, outputTails, timeoutKill, trust, wrongness, scheduler: scheduler.state });
+    const proof = await writeAgentProofEvidence(ledgerRoot, {
+        missionId,
+        backend,
+        route,
+        routeCommand,
+        routeBlackboxKind,
+        requestedWorkItems: desiredWorkItemCount,
+        minimumWorkItems,
+        targetActiveSlots,
+        realParallel: backend === 'codex-exec' && opts.mock !== true,
+        roster,
+        partition,
+        consensus,
+        results,
+        cleanup,
+        janitor,
+        outputTails,
+        timeoutKill,
+        trust,
+        wrongness,
+        scheduler: scheduler.state
+    });
     await writeAgentCodexCockpitArtifacts(dir, { missionId, projectHash: namespace.root_hash });
     await setCurrent(root, { mission_id: missionId, mode: 'AGENT', phase: proof.ok ? 'AGENT_NATIVE_KERNEL_DONE' : 'AGENT_NATIVE_KERNEL_BLOCKED', native_agent_backend: backend, updated_at: nowIso() });
     return {
@@ -218,11 +244,17 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         ok: proof.ok,
         mission_id: missionId,
         route,
+        route_command: routeCommand,
+        route_blackbox_kind: routeBlackboxKind,
         backend,
         ledger_root: path.relative(root, ledgerRoot),
         roster,
         partition: { ok: partition.ok, slice_count: partition.slices.length, lease_count: partition.leases.length, blockers: partition.blockers },
         task_graph: partition.task_graph?.route_work_count_summary || null,
+        requested_work_items: desiredWorkItemCount,
+        actual_total_work_items: partition.task_graph?.total_work_items || partition.slices.length,
+        target_active_slots: targetActiveSlots,
+        minimum_work_items: minimumWorkItems,
         scheduler,
         source_intelligence: sourceIntelligenceRef,
         goal_mode: goalModeRef,
@@ -247,6 +279,32 @@ function normalizeDesiredWorkItemCount(value, minimumValue, targetActiveSlots) {
         return Math.max(1, Math.floor(fallback));
     return Math.max(1, Math.floor(parsed));
 }
+function normalizeMinimumWorkItems(value, targetActiveSlots) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed < 1)
+        return Math.max(1, Math.floor(targetActiveSlots));
+    return Math.max(1, Math.floor(parsed));
+}
+function defaultRouteCommand(route) {
+    const normalized = String(route || '$Agent');
+    if (/team/i.test(normalized))
+        return 'sks team';
+    if (/research|autoresearch/i.test(normalized))
+        return 'sks research run';
+    if (/qa/i.test(normalized))
+        return 'sks qa-loop run';
+    return 'sks agent run';
+}
+function defaultRouteBlackboxKind(route) {
+    const normalized = String(route || '$Agent');
+    if (/team/i.test(normalized))
+        return 'actual_team_command';
+    if (/research|autoresearch/i.test(normalized))
+        return 'actual_research_command';
+    if (/qa/i.test(normalized))
+        return 'actual_qa_command';
+    return 'actual_agent_command';
+}
 function buildProvidedAgentRoster(input, opts = {}) {
     const sourceRows = Array.isArray(input?.roster) ? input.roster : Array.isArray(input?.personas) ? input.personas : [];
     if (!sourceRows.length)

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

@@ -1,6 +1,12 @@
 export declare function writeAgentProofEvidence(root: string, input: {
     missionId: string;
     backend: string;
+    route?: string;
+    routeCommand?: string;
+    routeBlackboxKind?: string;
+    requestedWorkItems?: number;
+    minimumWorkItems?: number;
+    targetActiveSlots?: number;
     realParallel?: boolean;
     roster?: any;
     partition?: any;
@@ -20,6 +26,10 @@ export declare function writeAgentProofEvidence(root: string, input: {
     generated_at: string;
     mission_id: string;
     backend: string;
+    route: string;
+    route_command: string;
+    route_blackbox_kind: string;
+    real_route_command_used: boolean;
     real_parallel_claim: boolean;
     fake_backend_disclaimer: string | null;
     agent_count: any;
@@ -35,26 +45,42 @@ export declare function writeAgentProofEvidence(root: string, input: {
     session_generation_count: number;
     all_generations_closed: boolean;
     scheduler_state: string;
-    target_active_slots: any;
+    target_active_slots: number;
+    requested_work_items: number;
+    actual_total_work_items: number;
+    minimum_work_items: number;
+    task_graph_total_work_items: number;
+    work_queue_total_work_items: number;
+    scheduler_total_work_items: number;
+    task_graph_matches_cli_options: boolean;
+    work_queue_matches_task_graph: boolean;
+    scheduler_matches_work_queue: boolean;
     max_observed_active_slots: any;
     pending_queue_drained: boolean;
     backfill_count: any;
     expected_backfill_count: any;
+    backfill_expected_for_route: boolean;
     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;
+    task_graph_source_refs_ok: any;
+    task_graph_goal_refs_ok: any;
+    work_queue_source_refs_ok: any;
+    work_queue_goal_refs_ok: any;
     tmux_lane_manifest: string;
     tmux_lane_manifest_ok: boolean;
     tmux_lane_supervisor: string;
+    lane_supervisor_integrated: boolean;
     tmux_lane_no_flicker_verified: boolean;
     tmux_lane_survival_checked: boolean;
     tmux_lane_unexpected_close_count: number;
     tmux_lane_auto_reopen_count: number;
     tmux_pane_launch_ledger: string;
     tmux_pane_launch_count: number;
+    terminal_reports_match_generations: boolean;
     ledger_hash_chain_ok: boolean;
     no_overlap_ok: boolean;
     consensus_ok: boolean;

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

@@ -15,6 +15,7 @@ export async function writeAgentProofEvidence(root, input) {
     const laneSupervisor = await readTmuxLaneSupervisor(root);
     const workQueue = await readJson(path.join(root, 'agent-work-queue.json'), null);
     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 slots = await readJson(path.join(root, 'agent-worker-slots.json'), null);
     const generationArtifact = await readJson(path.join(root, 'agent-session-generations.json'), null);
     const schedulerEvents = await readTextSafe(path.join(root, 'agent-scheduler-events.jsonl'));
@@ -23,6 +24,25 @@ export async function writeAgentProofEvidence(root, input) {
     const terminalCloseReportCount = terminal.total_sessions || 0;
     const generationCount = generations.generation_count || 0;
     const finalWorkItemCount = Number(scheduler?.completed_count || 0) + Number(scheduler?.failed_count || 0) + Number(scheduler?.blocked_count || 0);
+    const requestedWorkItems = Number(input.requestedWorkItems || taskGraph?.desired_work_items || taskGraph?.total_work_items || 0);
+    const taskGraphTotalWorkItems = Number(taskGraph?.total_work_items || 0);
+    const workQueueTotalWorkItems = Number(workQueue?.total_work_items || 0);
+    const schedulerTotalWorkItems = Number(scheduler?.total_work_items || 0);
+    const targetActiveSlots = Number(input.targetActiveSlots || scheduler?.target_active_slots || taskGraph?.target_active_slots || input.roster?.agent_count || 0);
+    const minimumWorkItems = Number(input.minimumWorkItems || taskGraph?.minimum_work_items || targetActiveSlots || 0);
+    const taskGraphMatchesCliOptions = Boolean(taskGraph) && requestedWorkItems === taskGraphTotalWorkItems && targetActiveSlots === Number(taskGraph.target_active_slots || 0);
+    const workQueueMatchesTaskGraph = Boolean(workQueue && taskGraph) && workQueueTotalWorkItems === taskGraphTotalWorkItems;
+    const schedulerMatchesWorkQueue = Boolean(scheduler && workQueue) && schedulerTotalWorkItems === workQueueTotalWorkItems;
+    const terminalReportsMatchGenerations = terminalCloseReportCount >= generationCount;
+    const taskGraphSourceRefsOk = Boolean(taskGraph?.work_items?.length) && taskGraph.work_items.every((item) => item.source_intelligence_refs);
+    const taskGraphGoalRefsOk = Boolean(taskGraph?.work_items?.length) && taskGraph.work_items.every((item) => item.goal_mode_ref);
+    const workQueueSourceRefsOk = Boolean(workQueue?.items?.length) && workQueue.items.every((item) => item.source_intelligence_refs);
+    const workQueueGoalRefsOk = Boolean(workQueue?.items?.length) && workQueue.items.every((item) => item.goal_mode_ref);
+    const route = String(input.route || taskGraph?.route_type || '$Agent');
+    const routeCommand = String(input.routeCommand || 'sks agent run');
+    const genericAgentRouteStandIn = !/\$?agent$/i.test(route) && /\bagent\s+run\b/i.test(routeCommand) && /--route/i.test(routeCommand);
+    const realRouteCommandUsed = !genericAgentRouteStandIn;
+    const laneSupervisorIntegrated = Boolean(laneSupervisor);
     const blockers = [
         ...(lifecycle.ok ? [] : ['agent_lifecycle_not_all_closed']),
         ...(lifecycle.ok ? [] : lifecycle.open_sessions.map((id) => 'session_open:' + id)),
@@ -40,6 +60,14 @@ export async function writeAgentProofEvidence(root, input) {
         ...(scheduler && Number(scheduler.active_slot_count || 0) !== 0 ? ['scheduler_active_slots_not_zero_at_finalization'] : []),
         ...(scheduler && Number(scheduler.expected_backfill_count || 0) > Number(scheduler.backfill_count || 0) ? ['scheduler_backfill_count_below_expected'] : []),
         ...(scheduler && Number(scheduler.total_work_items || 0) >= Number(scheduler.target_active_slots || 0) && Number(scheduler.max_observed_active_slots || 0) !== Number(scheduler.target_active_slots || 0) ? ['scheduler_max_observed_active_slots_mismatch'] : []),
+        ...(taskGraph && !taskGraphMatchesCliOptions ? ['task_graph_cli_options_mismatch'] : []),
+        ...(workQueue && taskGraph && !workQueueMatchesTaskGraph ? ['work_queue_task_graph_mismatch'] : []),
+        ...(scheduler && workQueue && !schedulerMatchesWorkQueue ? ['scheduler_work_queue_mismatch'] : []),
+        ...(taskGraph && !taskGraphSourceRefsOk ? ['task_graph_source_refs_missing'] : []),
+        ...(taskGraph && !taskGraphGoalRefsOk ? ['task_graph_goal_refs_missing'] : []),
+        ...(workQueue && !workQueueSourceRefsOk ? ['work_queue_source_refs_missing'] : []),
+        ...(workQueue && !workQueueGoalRefsOk ? ['work_queue_goal_refs_missing'] : []),
+        ...(genericAgentRouteStandIn ? ['non_agent_route_used_generic_agent_run_route_standin'] : []),
         ...(generationCount < finalWorkItemCount ? ['session_generation_count_below_finished_work_items'] : []),
         ...(terminalCloseReportCount < generationCount ? ['terminal_close_report_count_below_generation_count'] : []),
         ...(slots && slots.all_slots_closed_after_drain !== true ? ['agent_worker_slots_not_closed_after_drain'] : []),
@@ -64,6 +92,10 @@ export async function writeAgentProofEvidence(root, input) {
         generated_at: nowIso(),
         mission_id: input.missionId,
         backend: input.backend,
+        route,
+        route_command: routeCommand,
+        route_blackbox_kind: input.routeBlackboxKind || (realRouteCommandUsed ? 'actual_route_command' : 'generic_agent_route_standin'),
+        real_route_command_used: realRouteCommandUsed,
         real_parallel_claim: input.realParallel === true && input.backend === 'codex-exec',
         fake_backend_disclaimer: input.backend === 'fake' ? 'fixture only; no real parallel execution claim' : null,
         agent_count: input.roster?.agent_count || input.results?.length || 0,
@@ -79,26 +111,42 @@ export async function writeAgentProofEvidence(root, input) {
         session_generation_count: generations.generation_count,
         all_generations_closed: generations.ok,
         scheduler_state: 'agent-scheduler-state.json',
-        target_active_slots: scheduler?.target_active_slots || input.roster?.agent_count || 0,
+        target_active_slots: targetActiveSlots,
+        requested_work_items: requestedWorkItems,
+        actual_total_work_items: taskGraphTotalWorkItems || schedulerTotalWorkItems,
+        minimum_work_items: minimumWorkItems,
+        task_graph_total_work_items: taskGraphTotalWorkItems,
+        work_queue_total_work_items: workQueueTotalWorkItems,
+        scheduler_total_work_items: schedulerTotalWorkItems,
+        task_graph_matches_cli_options: taskGraphMatchesCliOptions,
+        work_queue_matches_task_graph: workQueueMatchesTaskGraph,
+        scheduler_matches_work_queue: schedulerMatchesWorkQueue,
         max_observed_active_slots: scheduler?.max_observed_active_slots || 0,
         pending_queue_drained: scheduler?.pending_queue_drained === true,
         backfill_count: scheduler?.backfill_count || 0,
         expected_backfill_count: scheduler?.expected_backfill_count || 0,
+        backfill_expected_for_route: Number(scheduler?.expected_backfill_count || 0) > 0,
         slot_count: slots?.slot_count || 0,
         generation_count: generationCount,
         all_slots_closed_after_drain: slots?.all_slots_closed_after_drain === true,
         generated_work_item_count: scheduler?.generated_work_item_count || 0,
         source_intelligence_generation_refs_ok: generations.missing_source_intelligence_refs.length === 0,
         goal_mode_generation_refs_ok: generations.missing_goal_mode_refs.length === 0,
+        task_graph_source_refs_ok: taskGraphSourceRefsOk,
+        task_graph_goal_refs_ok: taskGraphGoalRefsOk,
+        work_queue_source_refs_ok: workQueueSourceRefsOk,
+        work_queue_goal_refs_ok: workQueueGoalRefsOk,
         tmux_lane_manifest: 'agent-tmux-lanes.json',
         tmux_lane_manifest_ok: tmuxLanes?.ok === true,
         tmux_lane_supervisor: 'agent-tmux-lane-supervisor.json',
+        lane_supervisor_integrated: laneSupervisorIntegrated,
         tmux_lane_no_flicker_verified: laneSupervisor?.no_flicker_verified === true,
         tmux_lane_survival_checked: laneSupervisor?.pane_survival_checked === true,
         tmux_lane_unexpected_close_count: laneSupervisor?.unexpected_close_count || 0,
         tmux_lane_auto_reopen_count: laneSupervisor?.auto_reopen_count || 0,
         tmux_pane_launch_ledger: 'agent-tmux-pane-launch-ledger.jsonl',
         tmux_pane_launch_count: tmuxPaneLaunchCount,
+        terminal_reports_match_generations: terminalReportsMatchGenerations,
         ledger_hash_chain_ok: ledger.ok,
         no_overlap_ok: input.partition?.no_overlap_proof?.ok !== false,
         consensus_ok: input.consensus?.ok === true,

package/dist/core/agents/agent-runner-tmux.js

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { appendJsonl, runProcess, writeJsonAtomic } from '../fsx.js';
+import { appendJsonl, readJson, runProcess, writeJsonAtomic } from '../fsx.js';
 import { validateAgentWorkerResult } from './agent-worker-pipeline.js';
 export function buildTmuxAgentPanePlan(agent, slice = {}) {
     const agentId = String(agent?.id || 'agent');
@@ -68,6 +68,13 @@ async function writeAgentTmuxReport(root, agent, report) {
 async function launchTmuxPane(agent, slice, opts = {}) {
     const root = opts.agentRoot || opts.cwd || process.cwd();
     const sessionName = opts.tmuxSessionName || (opts.missionId ? `sks-${opts.missionId}` : 'sks-agent-runtime');
+    const supervisorEvidence = await recordSupervisorLaneEvidence(root, agent, slice, sessionName);
+    if (supervisorEvidence)
+        return supervisorEvidence;
+    if (opts.real === true) {
+        const blocked = fakeLaunch(agent, sessionName, '', ['tmux_lane_supervisor_missing_for_real_tmux']);
+        return { ...blocked, blockers: ['tmux_lane_supervisor_missing_for_real_tmux'] };
+    }
     const title = `${agent.slot_id || agent.id} gen-${agent.generation_index || 1} ${slice?.id || 'work'}`;
     const laneFile = path.join(root, 'lanes', String(agent.slot_id || agent.id), 'lane.md');
     const drainFile = path.join(root, 'lanes', '.drain');
@@ -109,6 +116,33 @@ async function launchTmuxPane(agent, slice, opts = {}) {
     await appendJsonl(path.join(root, 'agent-tmux-pane-launch-ledger.jsonl'), evidence);
     return evidence;
 }
+async function recordSupervisorLaneEvidence(root, agent, slice, sessionName) {
+    const supervisor = await readJson(path.join(root, 'agent-tmux-lane-supervisor.json'), null);
+    const slotId = String(agent.slot_id || agent.id);
+    const lane = supervisor?.lanes?.find((row) => String(row.slot_id) === slotId);
+    if (!lane?.pane_id)
+        return null;
+    const evidence = {
+        schema: 'sks.agent-tmux-pane-launch.v1',
+        generated_at: new Date().toISOString(),
+        launch_mode: lane.launch_mode || 'supervisor_slot_lane',
+        agent_id: agent.id,
+        slot_id: slotId,
+        generation_index: agent.generation_index || 1,
+        session_id: agent.session_id,
+        session_name: supervisor.session_name || sessionName,
+        window_id: null,
+        pane_id: lane.pane_id,
+        command: lane.command,
+        attach_command: `tmux attach -t ${supervisor.session_name || sessionName}`,
+        persistent_slot_lane: true,
+        reused_persistent_slot_lane: true,
+        work_item_id: slice?.id || null,
+        blockers: lane.launch_error ? [`tmux_lane_launch_error:${lane.launch_error}`] : []
+    };
+    await appendJsonl(path.join(root, 'agent-tmux-pane-launch-ledger.jsonl'), evidence);
+    return evidence;
+}
 function fakeLaunch(agent, sessionName, command, warnings) {
     const paneId = `fake-pane-${String(agent.slot_id || agent.id)}`;
     return {

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

@@ -71,6 +71,8 @@ export interface AgentRunOptions {
     desiredWorkItemCount?: number;
     minimumWorkItems?: number;
     maxQueueExpansion?: number;
+    routeCommand?: string;
+    routeBlackboxKind?: string;
     refillDelayMs?: number;
     roster?: unknown;
     backend?: AgentBackend | string;

package/dist/core/agents/route-collaboration-ledger.d.ts

@@ -63,6 +63,8 @@ export declare function writeRouteCollaborationArtifacts(root: string, opts: {
         ok: boolean;
         mission_id: any;
         route: string;
+        route_command: string;
+        route_blackbox_kind: string;
         backend: "tmux" | "fake" | "process" | "codex-exec";
         ledger_root: string;
         roster: {
@@ -120,6 +122,10 @@ export declare function writeRouteCollaborationArtifacts(root: string, opts: {
             generated_from_route: string;
             work_items_exceed_active_slots: boolean;
         };
+        requested_work_items: number;
+        actual_total_work_items: number;
+        target_active_slots: number;
+        minimum_work_items: number;
         scheduler: {
             schema: string;
             ok: boolean;
@@ -278,6 +284,10 @@ export declare function writeRouteCollaborationArtifacts(root: string, opts: {
             generated_at: string;
             mission_id: string;
             backend: string;
+            route: string;
+            route_command: string;
+            route_blackbox_kind: string;
+            real_route_command_used: boolean;
             real_parallel_claim: boolean;
             fake_backend_disclaimer: string | null;
             agent_count: any;
@@ -293,26 +303,42 @@ export declare function writeRouteCollaborationArtifacts(root: string, opts: {
             session_generation_count: number;
             all_generations_closed: boolean;
             scheduler_state: string;
-            target_active_slots: any;
+            target_active_slots: number;
+            requested_work_items: number;
+            actual_total_work_items: number;
+            minimum_work_items: number;
+            task_graph_total_work_items: number;
+            work_queue_total_work_items: number;
+            scheduler_total_work_items: number;
+            task_graph_matches_cli_options: boolean;
+            work_queue_matches_task_graph: boolean;
+            scheduler_matches_work_queue: boolean;
             max_observed_active_slots: any;
             pending_queue_drained: boolean;
             backfill_count: any;
             expected_backfill_count: any;
+            backfill_expected_for_route: boolean;
             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;
+            task_graph_source_refs_ok: any;
+            task_graph_goal_refs_ok: any;
+            work_queue_source_refs_ok: any;
+            work_queue_goal_refs_ok: any;
             tmux_lane_manifest: string;
             tmux_lane_manifest_ok: boolean;
             tmux_lane_supervisor: string;
+            lane_supervisor_integrated: boolean;
             tmux_lane_no_flicker_verified: boolean;
             tmux_lane_survival_checked: boolean;
             tmux_lane_unexpected_close_count: number;
             tmux_lane_auto_reopen_count: number;
             tmux_pane_launch_ledger: string;
             tmux_pane_launch_count: number;
+            terminal_reports_match_generations: boolean;
             ledger_hash_chain_ok: boolean;
             no_overlap_ok: boolean;
             consensus_ok: boolean;

package/dist/core/agents/tmux-lane-supervisor.d.ts

@@ -8,6 +8,8 @@ export interface TmuxLaneSupervisorLane {
     lane_md: string;
     lane_json: string;
     command: string;
+    launch_mode: string;
+    launch_error: string | null;
     opened_at: string;
     closed_at: string | null;
     unexpected_close_count: number;
@@ -37,6 +39,7 @@ export declare function initializeTmuxLaneSupervisor(root: string, input: {
     missionId: string;
     sessionName?: string;
     targetActiveSlots: number;
+    launchRealTmux?: boolean;
 }): Promise<TmuxLaneSupervisorState>;
 export declare function updateTmuxLaneSupervisorFromSlots(root: string, input: {
     missionId: string;

package/dist/core/agents/tmux-lane-supervisor.js

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { appendJsonl, ensureDir, nowIso, readJson, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
+import { appendJsonl, ensureDir, nowIso, readJson, runProcess, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
 export const TMUX_LANE_SUPERVISOR_SCHEMA = 'sks.tmux-lane-supervisor.v1';
 export async function initializeTmuxLaneSupervisor(root, input) {
     const now = nowIso();
@@ -17,7 +17,7 @@ export async function initializeTmuxLaneSupervisor(root, input) {
         auto_reopen_count: 0,
         all_lanes_closed_after_drain: false,
         blockers: [],
-        lanes: Array.from({ length: input.targetActiveSlots }, (_, index) => createLane(input.missionId, sessionName, index + 1, now))
+        lanes: await createSupervisorLanes(root, input.missionId, sessionName, input.targetActiveSlots, now, input.launchRealTmux === true)
     };
     for (const lane of state.lanes)
         await writeLaneRender(root, lane, null, null);
@@ -117,6 +117,8 @@ function createLane(missionId, sessionName, index, openedAt) {
         lane_md: path.join(laneDir, 'lane.md'),
         lane_json: path.join(laneDir, 'lane.json'),
         command: buildPersistentLaneCommand(missionId, slotId),
+        launch_mode: 'fake_supervisor_lane',
+        launch_error: null,
         opened_at: openedAt,
         closed_at: null,
         unexpected_close_count: 0,
@@ -128,11 +130,64 @@ function createLane(missionId, sessionName, index, openedAt) {
         drained: false
     };
 }
+async function createSupervisorLanes(root, missionId, sessionName, targetActiveSlots, openedAt, launchRealTmux) {
+    const lanes = [];
+    if (launchRealTmux)
+        await ensureTmuxSession(sessionName).catch(() => null);
+    for (let index = 1; index <= targetActiveSlots; index += 1) {
+        const lane = createLane(missionId, sessionName, index, openedAt);
+        if (launchRealTmux)
+            lanes.push(await launchPersistentSlotLane(root, lane, sessionName));
+        else
+            lanes.push(lane);
+    }
+    return lanes;
+}
+async function ensureTmuxSession(sessionName) {
+    await runProcess('tmux', ['has-session', '-t', sessionName], { timeoutMs: 1000, maxOutputBytes: 4096 }).catch(async () => {
+        await runProcess('tmux', ['new-session', '-d', '-s', sessionName, '-n', 'orchestrator', 'sleep 3600'], { timeoutMs: 2000, maxOutputBytes: 4096 });
+    });
+}
+async function launchPersistentSlotLane(root, lane, sessionName) {
+    const command = persistentLaneCommandForRoot(root, lane.slot_id);
+    try {
+        const pane = await runProcess('tmux', ['split-window', '-t', sessionName, '-P', '-F', '#{pane_id}', '-h', command], { timeoutMs: 2000, maxOutputBytes: 4096 });
+        const paneId = pane.stdout.trim() || `%${Date.now()}`;
+        await appendJsonl(path.join(root, 'agent-tmux-pane-launch-ledger.jsonl'), {
+            schema: 'sks.agent-tmux-pane-launch.v1',
+            generated_at: nowIso(),
+            launch_mode: 'real_tmux_supervisor_slot_lane',
+            slot_id: lane.slot_id,
+            generation_index: null,
+            session_id: null,
+            session_name: sessionName,
+            pane_id: paneId,
+            command,
+            persistent_slot_lane: true,
+            launched_by: TMUX_LANE_SUPERVISOR_SCHEMA,
+            blockers: []
+        });
+        return { ...lane, pane_id: paneId, command, launch_mode: 'real_tmux_supervisor_slot_lane', launch_error: null };
+    }
+    catch (err) {
+        return {
+            ...lane,
+            command,
+            launch_mode: 'real_tmux_supervisor_failed',
+            launch_error: err instanceof Error ? err.message : String(err)
+        };
+    }
+}
 function buildPersistentLaneCommand(missionId, slotId) {
     const laneMd = path.join('agents', 'lanes', slotId, 'lane.md');
     const drain = path.join('agents', 'lanes', '.drain');
     return `while test ! -f ${JSON.stringify(drain)}; do clear; printf '%s\\n' ${JSON.stringify(`SKS ${missionId} ${slotId}`)}; test -f ${JSON.stringify(laneMd)} && cat ${JSON.stringify(laneMd)}; sleep 2; done`;
 }
+function persistentLaneCommandForRoot(root, slotId) {
+    const laneFile = path.join(root, 'lanes', slotId, 'lane.md');
+    const drainFile = path.join(root, 'lanes', '.drain');
+    return `while test ! -f ${JSON.stringify(drainFile)}; do clear; test -f ${JSON.stringify(laneFile)} && cat ${JSON.stringify(laneFile)}; sleep 2; done`;
+}
 async function writeLaneRender(root, lane, slot, state) {
     const laneJson = {
         schema: 'sks.tmux-lane-render.v1',
@@ -190,6 +245,7 @@ function summarizeSupervisor(state) {
         all_lanes_closed_after_drain: state.lanes.length > 0 && state.lanes.every((lane) => lane.drained && Boolean(lane.closed_at)),
         blockers: [
             ...(unexpected > 0 ? ['tmux_lane_unexpected_close_before_drain'] : []),
+            ...(state.lanes.some((lane) => lane.launch_mode === 'real_tmux_supervisor_failed') ? ['tmux_lane_real_launch_failed'] : []),
             ...(state.lanes.some((lane) => lane.closed_at && !lane.drained) ? ['tmux_lane_closed_before_drain'] : [])
         ]
     };

package/dist/core/commands/agent-command.js

@@ -16,7 +16,7 @@ export async function agentCommand(commandOrArgs = 'agent', maybeArgs = []) {
     return agentMissionAction(parsed);
 }
 async function agentRun(parsed) {
-    const result = await runNativeAgentOrchestrator(parsed);
+    const result = await runNativeAgentOrchestrator({ ...parsed, routeCommand: 'sks agent run', routeBlackboxKind: 'actual_agent_command' });
     return emit(parsed, result, () => {
         console.log('Native agent mission: ' + result.mission_id);
         console.log('Backend: ' + result.backend);

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

@@ -385,6 +385,8 @@ export declare function imageUxReviewCommand(command: any, args?: any): Promise<
             ok: boolean;
             mission_id: any;
             route: string;
+            route_command: string;
+            route_blackbox_kind: string;
             backend: "tmux" | "fake" | "process" | "codex-exec";
             ledger_root: string;
             roster: {
@@ -442,6 +444,10 @@ export declare function imageUxReviewCommand(command: any, args?: any): Promise<
                 generated_from_route: string;
                 work_items_exceed_active_slots: boolean;
             };
+            requested_work_items: number;
+            actual_total_work_items: number;
+            target_active_slots: number;
+            minimum_work_items: number;
             scheduler: {
                 schema: string;
                 ok: boolean;
@@ -600,6 +606,10 @@ export declare function imageUxReviewCommand(command: any, args?: any): Promise<
                 generated_at: string;
                 mission_id: string;
                 backend: string;
+                route: string;
+                route_command: string;
+                route_blackbox_kind: string;
+                real_route_command_used: boolean;
                 real_parallel_claim: boolean;
                 fake_backend_disclaimer: string | null;
                 agent_count: any;
@@ -615,26 +625,42 @@ export declare function imageUxReviewCommand(command: any, args?: any): Promise<
                 session_generation_count: number;
                 all_generations_closed: boolean;
                 scheduler_state: string;
-                target_active_slots: any;
+                target_active_slots: number;
+                requested_work_items: number;
+                actual_total_work_items: number;
+                minimum_work_items: number;
+                task_graph_total_work_items: number;
+                work_queue_total_work_items: number;
+                scheduler_total_work_items: number;
+                task_graph_matches_cli_options: boolean;
+                work_queue_matches_task_graph: boolean;
+                scheduler_matches_work_queue: boolean;
                 max_observed_active_slots: any;
                 pending_queue_drained: boolean;
                 backfill_count: any;
                 expected_backfill_count: any;
+                backfill_expected_for_route: boolean;
                 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;
+                task_graph_source_refs_ok: any;
+                task_graph_goal_refs_ok: any;
+                work_queue_source_refs_ok: any;
+                work_queue_goal_refs_ok: any;
                 tmux_lane_manifest: string;
                 tmux_lane_manifest_ok: boolean;
                 tmux_lane_supervisor: string;
+                lane_supervisor_integrated: boolean;
                 tmux_lane_no_flicker_verified: boolean;
                 tmux_lane_survival_checked: boolean;
                 tmux_lane_unexpected_close_count: number;
                 tmux_lane_auto_reopen_count: number;
                 tmux_pane_launch_ledger: string;
                 tmux_pane_launch_count: number;
+                terminal_reports_match_generations: boolean;
                 ledger_hash_chain_ok: boolean;
                 no_overlap_ok: boolean;
                 consensus_ok: boolean;

package/dist/core/commands/ppt-command.d.ts

@@ -237,6 +237,8 @@ export declare function pptCommand(command: any, args?: any): Promise<void | {
             ok: boolean;
             mission_id: any;
             route: string;
+            route_command: string;
+            route_blackbox_kind: string;
             backend: "tmux" | "fake" | "process" | "codex-exec";
             ledger_root: string;
             roster: {
@@ -294,6 +296,10 @@ export declare function pptCommand(command: any, args?: any): Promise<void | {
                 generated_from_route: string;
                 work_items_exceed_active_slots: boolean;
             };
+            requested_work_items: number;
+            actual_total_work_items: number;
+            target_active_slots: number;
+            minimum_work_items: number;
             scheduler: {
                 schema: string;
                 ok: boolean;
@@ -452,6 +458,10 @@ export declare function pptCommand(command: any, args?: any): Promise<void | {
                 generated_at: string;
                 mission_id: string;
                 backend: string;
+                route: string;
+                route_command: string;
+                route_blackbox_kind: string;
+                real_route_command_used: boolean;
                 real_parallel_claim: boolean;
                 fake_backend_disclaimer: string | null;
                 agent_count: any;
@@ -467,26 +477,42 @@ export declare function pptCommand(command: any, args?: any): Promise<void | {
                 session_generation_count: number;
                 all_generations_closed: boolean;
                 scheduler_state: string;
-                target_active_slots: any;
+                target_active_slots: number;
+                requested_work_items: number;
+                actual_total_work_items: number;
+                minimum_work_items: number;
+                task_graph_total_work_items: number;
+                work_queue_total_work_items: number;
+                scheduler_total_work_items: number;
+                task_graph_matches_cli_options: boolean;
+                work_queue_matches_task_graph: boolean;
+                scheduler_matches_work_queue: boolean;
                 max_observed_active_slots: any;
                 pending_queue_drained: boolean;
                 backfill_count: any;
                 expected_backfill_count: any;
+                backfill_expected_for_route: boolean;
                 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;
+                task_graph_source_refs_ok: any;
+                task_graph_goal_refs_ok: any;
+                work_queue_source_refs_ok: any;
+                work_queue_goal_refs_ok: any;
                 tmux_lane_manifest: string;
                 tmux_lane_manifest_ok: boolean;
                 tmux_lane_supervisor: string;
+                lane_supervisor_integrated: boolean;
                 tmux_lane_no_flicker_verified: boolean;
                 tmux_lane_survival_checked: boolean;
                 tmux_lane_unexpected_close_count: number;
                 tmux_lane_auto_reopen_count: number;
                 tmux_pane_launch_ledger: string;
                 tmux_pane_launch_count: number;
+                terminal_reports_match_generations: boolean;
                 ledger_hash_chain_ok: boolean;
                 no_overlap_ok: boolean;
                 consensus_ok: boolean;

package/dist/core/commands/qa-loop-command.js

@@ -121,15 +121,19 @@ async function qaLoopRun(args) {
     }
     const fallbackCycles = Number.parseInt(contract.answers?.MAX_QA_CYCLES, 10) || 8;
     const maxCycles = readMaxCycles(args, fallbackCycles);
-    const targetActiveSlots = readBoundedIntegerFlag(args, '--target-active-slots', 3, 1, 20);
+    const requestedAgents = readBoundedIntegerFlag(args, '--agents', 3, 1, 20);
+    const targetActiveSlots = readBoundedIntegerFlag(args, '--target-active-slots', requestedAgents, 1, 20);
     const desiredWorkItemCount = readBoundedIntegerFlag(args, '--work-items', targetActiveSlots, 1, 200);
+    const minimumWorkItems = readBoundedIntegerFlag(args, '--minimum-work-items', targetActiveSlots, 1, 200);
+    const maxQueueExpansion = readBoundedIntegerFlag(args, '--max-queue-expansion', 10, 0, 200);
     const mock = flag(args, '--mock');
     const qaGate = await readJson(path.join(dir, 'qa-gate.json'), {});
     const reportFile = qaGate.qa_report_file;
     await setCurrent(root, { mission_id: id, route: 'QALoop', route_command: '$QA-LOOP', mode: 'QALOOP', phase: 'QALOOP_RUNNING_NO_QUESTIONS', questions_allowed: false, stop_gate: 'qa-gate.json', reasoning_effort: 'high', reasoning_profile: 'sks-logic-high', reasoning_temporary: true });
     await appendJsonlBounded(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'qaloop.run.started', maxCycles, mock });
     const nativeAgentPlan = await readJson(path.join(dir, 'qa-agent-plan.json'), null);
-    const nativeAgentRun = await runNativeAgentOrchestrator({ root, missionId: id, route: '$QA-LOOP', prompt: mission.prompt || 'QA-LOOP run', backend: mock ? 'fake' : 'codex-exec', mock, agents: 3, targetActiveSlots, desiredWorkItemCount, concurrency: 3, readonly: true, roster: nativeAgentPlan });
+    const nativeRoster = requestedAgents === 3 ? nativeAgentPlan : null;
+    const nativeAgentRun = await runNativeAgentOrchestrator({ root, missionId: id, route: '$QA-LOOP', prompt: mission.prompt || 'QA-LOOP run', backend: mock ? 'fake' : 'codex-exec', mock, agents: requestedAgents, targetActiveSlots, desiredWorkItemCount, minimumWorkItems, maxQueueExpansion, concurrency: Math.min(requestedAgents, 5), readonly: true, roster: nativeRoster, routeCommand: 'sks qa-loop run', routeBlackboxKind: 'actual_qa_command' });
     await writeJsonAtomic(path.join(dir, 'qa-native-agent-run.json'), nativeAgentRun);
     await appendJsonlBounded(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'qaloop.native_agents.completed', backend: nativeAgentRun.backend, ok: nativeAgentRun.ok, proof: nativeAgentRun.proof?.status });
     if (mock) {
@@ -146,7 +150,7 @@ async function qaLoopRun(args) {
         const proof = await maybeFinalizeRoute(root, { missionId: id, route: '$QA-LOOP', gateFile: 'qa-gate.json', gate: gate.gate || gate, artifacts: ['agents/agent-proof-evidence.json', 'qa-native-agent-run.json', 'qa-gate.json', 'qa-ledger.json', reportFile, 'completion-proof.json'], visual: needsVisual, mock, command: { cmd: `sks qa-loop run ${id} --mock`, status: 0 } });
         await setCurrent(root, { mission_id: id, mode: 'QALOOP', phase: gate.passed ? 'QALOOP_DONE' : 'QALOOP_PAUSED', questions_allowed: true });
         if (flag(args, '--json'))
-            return console.log(JSON.stringify({ schema: 'sks.qa-loop-run.v1', ok: proof.ok, mission_id: id, gate, proof: proof.validation }, null, 2));
+            return console.log(JSON.stringify({ schema: 'sks.qa-loop-run.v1', ok: proof.ok, mission_id: id, gate, proof: proof.validation, native_agent_run: nativeAgentRun }, null, 2));
         console.log(`Mock QA-LOOP done: ${id}`);
         console.log(`Gate: ${gate.passed ? 'passed' : 'blocked'}`);
         return;

package/dist/core/commands/research-command.js

@@ -112,14 +112,17 @@ async function researchRun(args) {
         return;
     }
     const maxCycles = readMaxCycles(args, RESEARCH_DEFAULT_MAX_CYCLES);
-    const targetActiveSlots = readBoundedIntegerFlag(args, '--target-active-slots', plan.native_agent_plan?.session_count || 5, 1, 20);
+    const requestedAgents = readBoundedIntegerFlag(args, '--agents', plan.native_agent_plan?.session_count || 5, 1, 20);
+    const targetActiveSlots = readBoundedIntegerFlag(args, '--target-active-slots', requestedAgents, 1, 20);
     const desiredWorkItemCount = readBoundedIntegerFlag(args, '--work-items', targetActiveSlots, 1, 200);
+    const minimumWorkItems = readBoundedIntegerFlag(args, '--minimum-work-items', targetActiveSlots, 1, 200);
+    const maxQueueExpansion = readBoundedIntegerFlag(args, '--max-queue-expansion', 10, 0, 200);
     const cycleTimeoutMinutes = readResearchCycleTimeoutMinutes(args);
     const cycleTimeoutMs = cycleTimeoutMinutes * 60 * 1000;
     const mock = flag(args, '--mock');
     await setCurrent(root, { mission_id: id, mode: 'RESEARCH', phase: 'RESEARCH_RUNNING_NO_QUESTIONS', questions_allowed: false, implementation_allowed: false, research_real_run_required: !mock, research_cycle_timeout_minutes: cycleTimeoutMinutes });
     await appendJsonlBounded(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'research.run.started', maxCycles, mock, cycleTimeoutMinutes, real_run_required: !mock });
-    const nativeAgentRun = await runNativeAgentOrchestrator({ root, missionId: id, route: flag(args, '--autoresearch') ? '$AutoResearch' : '$Research', prompt: mission.prompt || plan.prompt || 'Research run', backend: mock ? 'fake' : 'codex-exec', mock, agents: plan.native_agent_plan?.session_count || 5, targetActiveSlots, desiredWorkItemCount, concurrency: Math.min(plan.native_agent_plan?.session_count || 5, 5), readonly: true, roster: plan.native_agent_plan });
+    const nativeAgentRun = await runNativeAgentOrchestrator({ root, missionId: id, route: flag(args, '--autoresearch') ? '$AutoResearch' : '$Research', prompt: mission.prompt || plan.prompt || 'Research run', backend: mock ? 'fake' : 'codex-exec', mock, agents: requestedAgents, targetActiveSlots, desiredWorkItemCount, minimumWorkItems, maxQueueExpansion, concurrency: Math.min(requestedAgents, 5), readonly: true, roster: plan.native_agent_plan, routeCommand: 'sks research run', routeBlackboxKind: 'actual_research_command' });
     await writeJsonAtomic(path.join(dir, 'research-native-agent-run.json'), nativeAgentRun);
     await appendJsonlBounded(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'research.native_agents.completed', backend: nativeAgentRun.backend, ok: nativeAgentRun.ok, proof: nativeAgentRun.proof?.status });
     if (mock) {
@@ -130,7 +133,7 @@ async function researchRun(args) {
         const proof = await maybeFinalizeRoute(root, { missionId: id, route: '$Research', gateFile: 'research-gate.json', gate: gate.gate || gate, artifacts: ['agents/agent-proof-evidence.json', 'research-native-agent-run.json', 'research-gate.json', 'research-report.md', researchPaperArtifactForPlan(plan), 'source-ledger.json', 'agent-ledger.json', 'debate-ledger.json', 'completion-proof.json'], mock, command: { cmd: `sks research run ${id} --mock`, status: 0 } });
         await setCurrent(root, { mission_id: id, mode: 'RESEARCH', phase: gate.passed ? 'RESEARCH_DONE' : 'RESEARCH_PAUSED', questions_allowed: true, implementation_allowed: false });
         if (flag(args, '--json'))
-            return console.log(JSON.stringify({ schema: flag(args, '--autoresearch') ? 'sks.autoresearch-run.v1' : 'sks.research-run.v1', ok: proof.ok, mission_id: id, gate, proof: proof.validation, agent_batches: plan.agent_batches, autoresearch_cycle_policy: plan.autoresearch_cycle_policy }, null, 2));
+            return console.log(JSON.stringify({ schema: flag(args, '--autoresearch') ? 'sks.autoresearch-run.v1' : 'sks.research-run.v1', ok: proof.ok, mission_id: id, gate, proof: proof.validation, native_agent_run: nativeAgentRun, agent_batches: plan.agent_batches, autoresearch_cycle_policy: plan.autoresearch_cycle_policy }, null, 2));
         console.log(`Mock research done: ${id}`);
         console.log(`Gate: ${gate.passed ? 'passed' : 'blocked'}`);
         return;

package/dist/core/commands/team-command.js

@@ -30,6 +30,8 @@ export async function team(args = []) {
     const { prompt, agentSessions, roleCounts, roster } = opts;
     const targetActiveSlots = readBoundedIntegerFlag(args, '--target-active-slots', roster.bundle_size, 1, 20);
     const desiredWorkItemCount = readBoundedIntegerFlag(args, '--work-items', targetActiveSlots, 1, 200);
+    const minimumWorkItems = readBoundedIntegerFlag(args, '--minimum-work-items', targetActiveSlots, 1, 200);
+    const maxQueueExpansion = readBoundedIntegerFlag(args, '--max-queue-expansion', 10, 0, 200);
     if (!prompt) {
         console.error('Usage: sks team "task" [20:agents] [executor:5 reviewer:6 user:1] [--agents N] [--work-items N] [--target-active-slots N] [--no-open-tmux] [--json] [--mock]');
         process.exitCode = 1;
@@ -81,8 +83,12 @@ export async function team(args = []) {
         agents: roster.bundle_size,
         targetActiveSlots,
         desiredWorkItemCount,
+        minimumWorkItems,
+        maxQueueExpansion,
         concurrency: Math.min(agentSessions, roster.bundle_size),
-        readonly: true
+        readonly: true,
+        routeCommand: 'sks team',
+        routeBlackboxKind: 'actual_team_command'
     });
     await appendTeamEvent(dir, {
         agent: 'native_agent_orchestrator',
@@ -120,6 +126,8 @@ export async function team(args = []) {
         bundle_size: roster.bundle_size,
         target_active_slots: targetActiveSlots,
         desired_work_items: desiredWorkItemCount,
+        minimum_work_items: minimumWorkItems,
+        max_queue_expansion: maxQueueExpansion,
         role_counts: roleCounts,
         questions: path.join(dir, 'questions.md'),
         native_agent_run: nativeAgentRun,

package/dist/core/fsx.d.ts

@@ -1,4 +1,4 @@
-export declare const PACKAGE_VERSION = "1.18.2";
+export declare const PACKAGE_VERSION = "1.18.3";
 export declare const DEFAULT_PROCESS_TAIL_BYTES: number;
 export declare const DEFAULT_PROCESS_TIMEOUT_MS: number;
 export interface RunProcessOptions {

package/dist/core/fsx.js

@@ -5,7 +5,7 @@ import os from 'node:os';
 import crypto from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-export const PACKAGE_VERSION = '1.18.2';
+export const PACKAGE_VERSION = '1.18.3';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 export function nowIso() {

package/dist/core/version.d.ts

@@ -1,2 +1,2 @@
-export declare const PACKAGE_VERSION = "1.18.2";
+export declare const PACKAGE_VERSION = "1.18.3";
 //# sourceMappingURL=version.d.ts.map

package/dist/core/version.js

@@ -1,2 +1,2 @@
-export const PACKAGE_VERSION = '1.18.2';
+export const PACKAGE_VERSION = '1.18.3';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "1.18.2",
+  "version": "1.18.3",
   "description": "Sneakoscope Codex: fast proof-first Codex trust layer with image-based Voxel TriWiki.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",
@@ -238,11 +238,19 @@
     "agent:follow-up-work-schema": "node ./scripts/agent-follow-up-work-schema-check.mjs",
     "agent:dynamic-pool-route-blackbox": "node ./scripts/agent-dynamic-pool-route-blackbox.mjs",
     "agent:backfill-route-blackbox": "node ./scripts/agent-backfill-route-blackbox.mjs",
+    "agent:cli-options-to-task-graph": "node ./scripts/agent-cli-options-to-task-graph-check.mjs",
+    "agent:route-truth-backfill": "node ./scripts/agent-route-truth-backfill-check.mjs",
     "team:backfill-route-blackbox": "node ./scripts/team-backfill-route-blackbox.mjs",
+    "team:actual-route-backfill": "node ./scripts/team-actual-route-backfill-check.mjs",
     "research:backfill-route-blackbox": "node ./scripts/research-backfill-route-blackbox.mjs",
+    "research:actual-route-backfill": "node ./scripts/research-actual-route-backfill-check.mjs",
     "qa:backfill-route-blackbox": "node ./scripts/qa-backfill-route-blackbox.mjs",
+    "qa:actual-route-backfill": "node ./scripts/qa-actual-route-backfill-check.mjs",
     "agent:tmux-lane-persistence": "node ./scripts/agent-tmux-lane-persistence-check.mjs",
     "agent:tmux-lane-no-flicker": "node ./scripts/agent-tmux-lane-no-flicker-check.mjs",
+    "agent:tmux-supervisor-integrated": "node ./scripts/agent-tmux-supervisor-integrated-check.mjs",
+    "agent:tmux-slot-lane-runtime": "node ./scripts/agent-tmux-slot-lane-runtime-check.mjs",
+    "agent:proof-contract-reconciled": "node ./scripts/agent-proof-contract-reconciled-check.mjs",
     "agent:scheduler-proof-hardening": "node ./scripts/agent-scheduler-proof-hardening-check.mjs",
     "agent:dynamic-pool": "node ./scripts/agent-dynamic-pool-check.mjs",
     "agent:backfill-replenishment": "node ./scripts/agent-backfill-replenishment-check.mjs",