cluxion-agentplugin-preprocessing 0.3.11__tar.gz → 0.3.13__tar.gz

{cluxion_agentplugin_preprocessing-0.3.11 → cluxion_agentplugin_preprocessing-0.3.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cluxion-agentplugin-preprocessing
-Version: 0.3.11
+Version: 0.3.13
 Summary: Universal agent plugin for Cluxion preprocessing, honesty contracts, clarification, Rust work queue, and resource-aware harness handoff.
 Project-URL: Homepage, https://github.com/cluxion/cluxion-Agentplugin-preprocessing
 Project-URL: Repository, https://github.com/cluxion/cluxion-Agentplugin-preprocessing

{cluxion_agentplugin_preprocessing-0.3.11 → cluxion_agentplugin_preprocessing-0.3.13}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "cluxion-agentplugin-preprocessing"
-version = "0.3.11"
+version = "0.3.13"
 description = "Universal agent plugin for Cluxion preprocessing, honesty contracts, clarification, Rust work queue, and resource-aware harness handoff."
 readme = "README.md"
 requires-python = ">=3.11"

{cluxion_agentplugin_preprocessing-0.3.11 → cluxion_agentplugin_preprocessing-0.3.13}/rust/cluxion_queue/Cargo.lock

@@ -53,8 +53,9 @@ checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
 [[package]]
 name = "cluxion_queue"
-version = "0.2.0"
+version = "0.2.1"
 dependencies = [
+ "fs2",
  "pyo3",
  "rusqlite",
  "serde",
@@ -148,6 +149,16 @@ version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
 
+[[package]]
+name = "fs2"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9564fc758e15025b46aa6643b1b77d047d1a56a1aea6e01002ac0c7026876213"
+dependencies = [
+ "libc",
+ "winapi",
+]
+
 [[package]]
 name = "generic-array"
 version = "0.14.7"

{cluxion_agentplugin_preprocessing-0.3.11 → cluxion_agentplugin_preprocessing-0.3.13}/rust/cluxion_queue/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cluxion_queue"
-version = "0.2.0"
+version = "0.2.1"
 edition = "2021"
 description = "Durable work queue and dispatch store for Cluxion agent preprocessing"
 
@@ -20,6 +20,7 @@ rusqlite = { version = "0.32", features = ["bundled"] }
 sysinfo = "0.33"
 thiserror = "2"
 pyo3 = { version = "0.23", features = ["abi3-py311"], optional = true }
+fs2 = "0.4"
 
 [features]
 default = []

{cluxion_agentplugin_preprocessing-0.3.11 → cluxion_agentplugin_preprocessing-0.3.13}/rust/cluxion_queue/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "cluxion-queue-native"
-version = "0.2.0"
+version = "0.2.1"
 description = "In-process Rust queue engine for cluxion-agentplugin-preprocessing"
 requires-python = ">=3.11"
 license = "Apache-2.0"

{cluxion_agentplugin_preprocessing-0.3.11 → cluxion_agentplugin_preprocessing-0.3.13}/rust/cluxion_queue/src/dispatch.rs

@@ -1,6 +1,7 @@
-use std::fs;
+use std::fs::{self, OpenOptions};
 use std::path::{Path, PathBuf};
 
+use fs2::FileExt;
 use serde_json::{json, Value};
 
 use crate::types::{ok_payload, require_str, QueueError};
@@ -14,49 +15,55 @@ pub fn persist_bundle(store_dir: &Path, payload: &Value) -> Result<Value, QueueE
     let dispatch_dir = dispatch_dir(store_dir);
     fs::create_dir_all(&dispatch_dir)?;
     let path = bundle_path(&dispatch_dir, work_id)?;
-    write_atomic_json(&path, &bundle)?;
-    Ok(ok_payload(json!({
-        "stored": true,
-        "path": path.to_string_lossy(),
-    })))
+    with_dispatch_lock(&dispatch_dir, || {
+        write_atomic_json(&path, &bundle)?;
+        Ok(ok_payload(json!({
+            "stored": true,
+            "path": path.to_string_lossy(),
+        })))
+    })
 }
 
 pub fn next_step(store_dir: &Path, payload: &Value) -> Result<Value, QueueError> {
     let work_id = require_str(payload, "work_id")?;
-    let path = bundle_path(&dispatch_dir(store_dir), work_id)?;
-    let mut bundle = read_bundle(&path)?;
-    let mut selected: Option<Value> = None;
-    {
-        let steps = steps_mut(&mut bundle)?;
-        for step in steps.iter_mut() {
-            let status = step.get("status").and_then(Value::as_str).unwrap_or("");
-            if status == "queued" || status == "retry_wait" {
-                step["status"] = json!("running");
-                step["updated_at"] = json!(now_secs());
-                selected = Some(public_step(step));
-                break;
+    let dispatch_dir = dispatch_dir(store_dir);
+    fs::create_dir_all(&dispatch_dir)?;
+    let path = bundle_path(&dispatch_dir, work_id)?;
+    with_dispatch_lock(&dispatch_dir, || {
+        let mut bundle = read_bundle(&path)?;
+        let mut selected: Option<Value> = None;
+        {
+            let steps = steps_mut(&mut bundle)?;
+            for step in steps.iter_mut() {
+                let status = step.get("status").and_then(Value::as_str).unwrap_or("");
+                if status == "queued" || status == "retry_wait" {
+                    step["status"] = json!("running");
+                    step["updated_at"] = json!(now_secs());
+                    selected = Some(public_step(step));
+                    break;
+                }
             }
         }
-    }
-    if let Some(step) = selected {
-        write_atomic_json(&path, &bundle)?;
-        let remaining = remaining_count(steps_ref(&bundle)?);
-        return Ok(ok_payload(json!({
+        if let Some(step) = selected {
+            write_atomic_json(&path, &bundle)?;
+            let remaining = remaining_count(steps_ref(&bundle)?);
+            return Ok(ok_payload(json!({
+                "work_id": work_id,
+                "ready": true,
+                "step": step,
+                "remaining": remaining,
+                "synthesis_ready": false,
+            })));
+        }
+        let steps = steps_ref(&bundle)?;
+        Ok(ok_payload(json!({
             "work_id": work_id,
-            "ready": true,
-            "step": step,
-            "remaining": remaining,
-            "synthesis_ready": false,
-        })));
-    }
-    let steps = steps_ref(&bundle)?;
-    Ok(ok_payload(json!({
-        "work_id": work_id,
-        "ready": false,
-        "step": json!({}),
-        "remaining": remaining_count(steps),
-        "synthesis_ready": steps.iter().all(|step| step.get("status") == Some(&json!("succeeded"))),
-    })))
+            "ready": false,
+            "step": json!({}),
+            "remaining": remaining_count(steps),
+            "synthesis_ready": steps.iter().all(|step| step.get("status") == Some(&json!("succeeded"))),
+        })))
+    })
 }
 
 pub fn record_step(store_dir: &Path, payload: &Value) -> Result<Value, QueueError> {
@@ -68,37 +75,41 @@ pub fn record_step(store_dir: &Path, payload: &Value) -> Result<Value, QueueErro
         .get("failed")
         .and_then(Value::as_bool)
         .unwrap_or(false);
-    let path = bundle_path(&dispatch_dir(store_dir), work_id)?;
-    let mut bundle = read_bundle(&path)?;
-    let mut recorded_status = None;
-    {
-        let steps = steps_mut(&mut bundle)?;
-        for step in steps.iter_mut() {
-            if step.get("step_id") == Some(&json!(step_id)) {
-                step["status"] = json!(if failed { "failed" } else { "succeeded" });
-                step["result"] = json!(result);
-                step["error"] = json!(error);
-                step["updated_at"] = json!(now_secs());
-                recorded_status = step.get("status").cloned();
-                break;
+    let dispatch_dir = dispatch_dir(store_dir);
+    fs::create_dir_all(&dispatch_dir)?;
+    let path = bundle_path(&dispatch_dir, work_id)?;
+    with_dispatch_lock(&dispatch_dir, || {
+        let mut bundle = read_bundle(&path)?;
+        let mut recorded_status = None;
+        {
+            let steps = steps_mut(&mut bundle)?;
+            for step in steps.iter_mut() {
+                if step.get("step_id") == Some(&json!(step_id)) {
+                    step["status"] = json!(if failed { "failed" } else { "succeeded" });
+                    step["result"] = json!(result);
+                    step["error"] = json!(error);
+                    step["updated_at"] = json!(now_secs());
+                    recorded_status = step.get("status").cloned();
+                    break;
+                }
             }
         }
-    }
-    if let Some(status) = recorded_status {
-        write_atomic_json(&path, &bundle)?;
-        let steps = steps_ref(&bundle)?;
-        return Ok(ok_payload(json!({
-            "work_id": work_id,
-            "step_id": step_id,
-            "recorded": true,
-            "status": status,
-            "remaining": remaining_count(steps),
-            "synthesis_ready": steps.iter().all(|item| item.get("status") == Some(&json!("succeeded"))),
-        })));
-    }
-    Err(QueueError::Store(format!(
-        "dispatch step not found: {work_id}/{step_id}"
-    )))
+        if let Some(status) = recorded_status {
+            write_atomic_json(&path, &bundle)?;
+            let steps = steps_ref(&bundle)?;
+            return Ok(ok_payload(json!({
+                "work_id": work_id,
+                "step_id": step_id,
+                "recorded": true,
+                "status": status,
+                "remaining": remaining_count(steps),
+                "synthesis_ready": steps.iter().all(|item| item.get("status") == Some(&json!("succeeded"))),
+            })));
+        }
+        Err(QueueError::Store(format!(
+            "dispatch step not found: {work_id}/{step_id}"
+        )))
+    })
 }
 
 pub fn build_brief(store_dir: &Path, payload: &Value) -> Result<Value, QueueError> {
@@ -133,6 +144,22 @@ pub fn build_brief(store_dir: &Path, payload: &Value) -> Result<Value, QueueErro
     })))
 }
 
+fn with_dispatch_lock<T>(
+    dispatch_dir: &Path,
+    f: impl FnOnce() -> Result<T, QueueError>,
+) -> Result<T, QueueError> {
+    let lock_path = dispatch_dir.join(".dispatch.lock");
+    let lockfile = OpenOptions::new()
+        .read(true)
+        .write(true)
+        .create(true)
+        .open(&lock_path)?;
+    lockfile.lock_exclusive()?;
+    let result = f();
+    let _ = lockfile.unlock();
+    result
+}
+
 fn dispatch_dir(store_dir: &Path) -> PathBuf {
     store_dir.join("dispatch")
 }

{cluxion_agentplugin_preprocessing-0.3.11 → cluxion_agentplugin_preprocessing-0.3.13}/rust/cluxion_queue/src/guard.rs

@@ -19,9 +19,13 @@ const DEFAULT_CPU_SAMPLE_MS: u64 = 100;
 const MAX_REPORTED_PIDS: usize = 50;
 const DEFAULT_CPU_HOT_THRESHOLD: f64 = 50.0;
 const DEFAULT_RSS_HOT_THRESHOLD_MB: u64 = 1024;
-pub const DEFAULT_DAEMON_INTERVAL_MS: u64 = 200;
-pub const DEFAULT_DAEMON_WINDOW: usize = 25;
+pub const DEFAULT_DAEMON_INTERVAL_MS: u64 = 1000;
+pub const DEFAULT_DAEMON_WINDOW: usize = 10;
+pub const PROC_SCAN_EVERY_N_TICKS: u64 = 5;
 pub const STATE_FILE_NAME: &str = "guard_state.json";
+pub const HEARTBEAT_FILE_NAME: &str = "guard_heartbeat";
+pub const PID_FILE_NAME: &str = "guard_daemon.pid";
+pub const DEFAULT_IDLE_TTL_MS: u64 = 600_000;
 
 fn epoch_ms() -> u64 {
     SystemTime::now()
@@ -30,6 +34,26 @@ fn epoch_ms() -> u64 {
         .unwrap_or(0)
 }
 
+fn idle_ttl_ms() -> u64 {
+    std::env::var("CLUXION_GUARD_IDLE_TTL_MS")
+        .ok()
+        .and_then(|raw| raw.parse::<u64>().ok())
+        .unwrap_or(DEFAULT_IDLE_TTL_MS)
+}
+
+/// True when the heartbeat mtime is older than `ttl_ms` relative to `now_ms`.
+pub fn is_idle(heartbeat_mtime_ms: u64, now_ms: u64, ttl_ms: u64) -> bool {
+    now_ms.saturating_sub(heartbeat_mtime_ms) > ttl_ms
+}
+
+fn heartbeat_mtime_ms(path: &Path) -> Option<u64> {
+    let modified = std::fs::metadata(path).ok()?.modified().ok()?;
+    modified
+        .duration_since(UNIX_EPOCH)
+        .ok()
+        .map(|duration| duration.as_millis() as u64)
+}
+
 fn uint_field(payload: &Value, key: &str, default: u64) -> u64 {
     payload.get(key).and_then(Value::as_u64).unwrap_or(default)
 }
@@ -48,7 +72,14 @@ pub fn sample(payload: &Value) -> Result<Value, QueueError> {
     Ok(sample_from(&sys))
 }
 
-fn sample_from(sys: &System) -> Value {
+#[derive(Clone, Debug, PartialEq, Eq)]
+struct ProcessScanCache {
+    process_count: usize,
+    zombie_count: usize,
+    zombie_pids: Vec<u64>,
+}
+
+fn scan_process_fields(sys: &System) -> ProcessScanCache {
     let mut zombie_pids: Vec<u64> = sys
         .processes()
         .iter()
@@ -58,19 +89,88 @@ fn sample_from(sys: &System) -> Value {
     zombie_pids.sort_unstable();
     let zombie_count = zombie_pids.len();
     zombie_pids.truncate(MAX_REPORTED_PIDS);
+    ProcessScanCache {
+        process_count: sys.processes().len(),
+        zombie_count,
+        zombie_pids,
+    }
+}
+
+fn build_current_snapshot(sys: &System, process_cache: &ProcessScanCache) -> Value {
     json!({
         "ok": true,
         "total_ram_mb": sys.total_memory() / 1_048_576,
         "available_ram_mb": sys.available_memory() / 1_048_576,
         "swap_used_mb": sys.used_swap() / 1_048_576,
         "cpu_percent": f64::from(sys.global_cpu_usage()),
-        "process_count": sys.processes().len(),
-        "zombie_count": zombie_count,
-        "zombie_pids": zombie_pids,
+        "process_count": process_cache.process_count,
+        "zombie_count": process_cache.zombie_count,
+        "zombie_pids": process_cache.zombie_pids.clone(),
         "sampled_at_ms": epoch_ms(),
     })
 }
 
+fn sample_from(sys: &System) -> Value {
+    build_current_snapshot(sys, &scan_process_fields(sys))
+}
+
+fn push_window_sample(
+    cpu_window: &mut Vec<f64>,
+    ram_window: &mut Vec<u64>,
+    window: usize,
+    cpu: f64,
+    ram: u64,
+) {
+    if cpu_window.len() == window {
+        cpu_window.remove(0);
+        ram_window.remove(0);
+    }
+    cpu_window.push(cpu);
+    ram_window.push(ram);
+}
+
+fn build_daemon_state(
+    current: &Value,
+    cpu_window: &[f64],
+    ram_window: &[u64],
+    interval_ms: u64,
+) -> Value {
+    json!({
+        "ok": true,
+        "current": current,
+        "window": {
+            "samples": cpu_window.len(),
+            "cpu_avg": cpu_window.iter().sum::<f64>() / cpu_window.len() as f64,
+            "cpu_peak": cpu_window.iter().cloned().fold(0.0, f64::max),
+            "min_available_ram_mb": ram_window.iter().min().copied().unwrap_or(0),
+        },
+        "interval_ms": interval_ms,
+        "updated_at_ms": epoch_ms(),
+    })
+}
+
+fn daemon_tick(
+    sys: &mut System,
+    process_cache: &mut ProcessScanCache,
+    cpu_window: &mut Vec<f64>,
+    ram_window: &mut Vec<u64>,
+    window: usize,
+    interval_ms: u64,
+    tick: u64,
+) -> Value {
+    if tick % PROC_SCAN_EVERY_N_TICKS == 0 {
+        sys.refresh_processes(ProcessesToUpdate::All, true);
+        *process_cache = scan_process_fields(sys);
+    }
+    sys.refresh_memory();
+    sys.refresh_cpu_usage();
+    let current = build_current_snapshot(sys, process_cache);
+    let cpu = current["cpu_percent"].as_f64().unwrap_or(0.0);
+    let ram = current["available_ram_mb"].as_u64().unwrap_or(0);
+    push_window_sample(cpu_window, ram_window, window, cpu, ram);
+    build_daemon_state(&current, cpu_window, ram_window, interval_ms)
+}
+
 /// Scan processes against registered owner roots. A process is `owned`
 /// only when its parent lineage reaches one of `owned_roots`; everything
 /// else — including processes whose lineage cannot be walked — is
@@ -157,50 +257,53 @@ fn is_owned(pid: u64, owned_roots: &[u64], parents: &HashMap<u64, u64>) -> bool
 }
 
 /// Polling daemon: refresh, fold into a rolling window, publish state
-/// atomically (write to a temp file, then rename). Runs until killed.
+/// atomically (write to a temp file, then rename). Self-exits when the
+/// heartbeat file is stale; otherwise runs until killed.
+///
+/// Cheap ticks refresh memory/CPU every `interval_ms`; full process scans run
+/// every [`PROC_SCAN_EVERY_N_TICKS`] ticks and their results are cached for
+/// intervening cheap ticks.
 pub fn run_daemon(store_dir: &Path, interval_ms: u64, window: usize) -> Result<(), QueueError> {
     std::fs::create_dir_all(store_dir)?;
     let state_path = store_dir.join(STATE_FILE_NAME);
     let tmp_path = store_dir.join(format!("{STATE_FILE_NAME}.tmp"));
+    let heartbeat_path = store_dir.join(HEARTBEAT_FILE_NAME);
+    let pid_path = store_dir.join(PID_FILE_NAME);
+    let idle_ttl = idle_ttl_ms();
     let interval = std::time::Duration::from_millis(interval_ms.max(100));
     let window = window.max(1);
+    let interval_ms = interval.as_millis() as u64;
 
     let mut sys = System::new();
-    sys.refresh_memory();
-    sys.refresh_cpu_usage();
+    let mut process_cache = ProcessScanCache {
+        process_count: 0,
+        zombie_count: 0,
+        zombie_pids: Vec::new(),
+    };
     let mut cpu_window: Vec<f64> = Vec::with_capacity(window);
     let mut ram_window: Vec<u64> = Vec::with_capacity(window);
+    let mut tick: u64 = 0;
 
     loop {
-        std::thread::sleep(interval);
-        sys.refresh_memory();
-        sys.refresh_cpu_usage();
-        sys.refresh_processes(ProcessesToUpdate::All, true);
-        let current = sample_from(&sys);
-
-        let cpu = current["cpu_percent"].as_f64().unwrap_or(0.0);
-        let ram = current["available_ram_mb"].as_u64().unwrap_or(0);
-        if cpu_window.len() == window {
-            cpu_window.remove(0);
-            ram_window.remove(0);
+        if let Some(mtime) = heartbeat_mtime_ms(&heartbeat_path) {
+            if is_idle(mtime, epoch_ms(), idle_ttl) {
+                let _ = std::fs::remove_file(&pid_path);
+                return Ok(());
+            }
         }
-        cpu_window.push(cpu);
-        ram_window.push(ram);
-
-        let state = json!({
-            "ok": true,
-            "current": current,
-            "window": {
-                "samples": cpu_window.len(),
-                "cpu_avg": cpu_window.iter().sum::<f64>() / cpu_window.len() as f64,
-                "cpu_peak": cpu_window.iter().cloned().fold(0.0, f64::max),
-                "min_available_ram_mb": ram_window.iter().min().copied().unwrap_or(0),
-            },
-            "interval_ms": interval.as_millis() as u64,
-            "updated_at_ms": epoch_ms(),
-        });
+        let state = daemon_tick(
+            &mut sys,
+            &mut process_cache,
+            &mut cpu_window,
+            &mut ram_window,
+            window,
+            interval_ms,
+            tick,
+        );
         std::fs::write(&tmp_path, serde_json::to_vec(&state)?)?;
         std::fs::rename(&tmp_path, &state_path)?;
+        tick += 1;
+        std::thread::sleep(interval);
     }
 }
 
@@ -262,4 +365,126 @@ mod tests {
         // No roots registered -> nothing is owned.
         assert!(!is_owned(10, &[], &parents));
     }
+
+    #[test]
+    fn daemon_tick_caches_process_fields_between_scans() {
+        let mut sys = System::new();
+        sys.refresh_processes(ProcessesToUpdate::All, true);
+        let mut process_cache = scan_process_fields(&sys);
+        let mut cpu_window: Vec<f64> = Vec::with_capacity(3);
+        let mut ram_window: Vec<u64> = Vec::with_capacity(3);
+
+        let scan_tick_state = daemon_tick(
+            &mut sys,
+            &mut process_cache,
+            &mut cpu_window,
+            &mut ram_window,
+            3,
+            1000,
+            0,
+        );
+        let scan_process_count = scan_tick_state["current"]["process_count"]
+            .as_u64()
+            .expect("process_count");
+        assert!(scan_process_count > 0);
+
+        let stale_cache = ProcessScanCache {
+            process_count: 1,
+            zombie_count: 2,
+            zombie_pids: vec![99, 100],
+        };
+        process_cache = stale_cache.clone();
+
+        let cheap_tick_state = daemon_tick(
+            &mut sys,
+            &mut process_cache,
+            &mut cpu_window,
+            &mut ram_window,
+            3,
+            1000,
+            1,
+        );
+        assert_eq!(
+            cheap_tick_state["current"]["process_count"].as_u64(),
+            Some(1)
+        );
+        assert_eq!(
+            cheap_tick_state["current"]["zombie_count"].as_u64(),
+            Some(2)
+        );
+        assert_eq!(
+            cheap_tick_state["current"]["zombie_pids"],
+            json!([99, 100])
+        );
+
+        let rescan_tick_state = daemon_tick(
+            &mut sys,
+            &mut process_cache,
+            &mut cpu_window,
+            &mut ram_window,
+            3,
+            1000,
+            PROC_SCAN_EVERY_N_TICKS,
+        );
+        assert_ne!(process_cache, stale_cache);
+        assert!(process_cache.process_count > 0);
+        assert_eq!(
+            rescan_tick_state["current"]["process_count"].as_u64(),
+            Some(process_cache.process_count as u64)
+        );
+    }
+
+    #[test]
+    fn is_idle_detects_stale_and_fresh_heartbeats() {
+        let ttl = 600_000;
+        let now = 1_700_000_000_000u64;
+        assert!(is_idle(now - ttl - 1, now, ttl));
+        assert!(!is_idle(now - ttl, now, ttl));
+        assert!(!is_idle(now - 1, now, ttl));
+    }
+
+    #[test]
+    fn daemon_state_json_has_required_keys() {
+        let mut sys = System::new();
+        sys.refresh_processes(ProcessesToUpdate::All, true);
+        let mut process_cache = scan_process_fields(&sys);
+        let mut cpu_window: Vec<f64> = Vec::with_capacity(2);
+        let mut ram_window: Vec<u64> = Vec::with_capacity(2);
+
+        let state = daemon_tick(
+            &mut sys,
+            &mut process_cache,
+            &mut cpu_window,
+            &mut ram_window,
+            2,
+            1000,
+            0,
+        );
+
+        for key in ["ok", "current", "window", "interval_ms", "updated_at_ms"] {
+            assert!(state.get(key).is_some(), "missing top-level key: {key}");
+        }
+        for key in [
+            "ok",
+            "total_ram_mb",
+            "available_ram_mb",
+            "swap_used_mb",
+            "cpu_percent",
+            "process_count",
+            "zombie_count",
+            "zombie_pids",
+            "sampled_at_ms",
+        ] {
+            assert!(
+                state["current"].get(key).is_some(),
+                "missing current key: {key}"
+            );
+        }
+        for key in ["samples", "cpu_avg", "cpu_peak", "min_available_ram_mb"] {
+            assert!(
+                state["window"].get(key).is_some(),
+                "missing window key: {key}"
+            );
+        }
+    }
 }

{cluxion_agentplugin_preprocessing-0.3.11 → cluxion_agentplugin_preprocessing-0.3.13}/rust/cluxion_queue/src/queue.rs

@@ -95,6 +95,8 @@ pub fn enqueue(store_dir: &Path, payload: &Value) -> Result<Value, QueueError> {
 pub fn dequeue(store_dir: &Path, _payload: &Value) -> Result<Value, QueueError> {
     let now = now_secs();
     with_db(store_dir, |conn| {
+        // Use BEGIN IMMEDIATE for atomic SELECT-then-UPDATE claim
+        conn.execute_batch("BEGIN IMMEDIATE;")?;
         let row = conn.query_row(
             "SELECT work_id, prompt, surface, priority, metadata_json
          FROM work_queue
@@ -118,6 +120,7 @@ pub fn dequeue(store_dir: &Path, _payload: &Value) -> Result<Value, QueueError>
                     "UPDATE work_queue SET status='running', updated_at=?2 WHERE work_id=?1",
                     params![work_id, now],
                 )?;
+                conn.execute_batch("COMMIT;")?;
                 Ok(ok_payload(json!({
                     "ready": true,
                     "item": {
@@ -129,11 +132,17 @@ pub fn dequeue(store_dir: &Path, _payload: &Value) -> Result<Value, QueueError>
                     }
                 })))
             }
-            Err(rusqlite::Error::QueryReturnedNoRows) => Ok(ok_payload(json!({
-                "ready": false,
-                "item": Value::Null,
-            }))),
-            Err(err) => Err(QueueError::Sqlite(err)),
+            Err(rusqlite::Error::QueryReturnedNoRows) => {
+                conn.execute_batch("COMMIT;")?;
+                Ok(ok_payload(json!({
+                    "ready": false,
+                    "item": Value::Null,
+                })))
+            }
+            Err(err) => {
+                let _ = conn.execute_batch("ROLLBACK;");
+                Err(QueueError::Sqlite(err))
+            }
         }
     })
 }

{cluxion_agentplugin_preprocessing-0.3.11 → cluxion_agentplugin_preprocessing-0.3.13}/src/cluxion_agentplugin_preprocessing/__init__.py

@@ -2,6 +2,6 @@
 
 from __future__ import annotations
 
-__version__ = "0.3.11"
+__version__ = "0.3.12"
 
 __all__ = ["__version__"]