failproofai 1.0.0-beta.3 → 1.0.0-beta.5

package/.next/standalone/crates/failproofaid/src/main.rs

@@ -93,23 +93,26 @@ fn run() -> Result<(), Box<dyn std::error::Error>> {
     // machine (see fpai_collect::supervisor). It observes the same `shutdown`
     // flag the server and the cloud monitor do, so one SIGTERM stops all three.
     //
-    // INERT until ingest is configured: `collector_tasks()` returns an empty
-    // list, `spawn_supervised` then declines to start a thread or a runtime at
-    // all, and the daemon behaves byte-for-byte as it did before this existed.
-    let collector = fpai_collect::spawn_supervised(collector_tasks(), shutdown.clone());
+    // INERT until ingest is configured. But the config is not necessarily
+    // ready at startup: `failproofai config` installs the daemon and THEN
+    // connects, so the very first daemon start usually sees no ingest yet. A
+    // manager thread waits for the config to become enabled and starts the
+    // collector once it is — the collector's analogue of the cloud lane
+    // re-resolving enrolment per tick, so enabling collection takes effect
+    // within one interval with no restart and no root (see
+    // `spawn_collector_manager`). The manager owns the collector's lifecycle,
+    // including draining it on shutdown.
+    let collector_mgr = spawn_collector_manager(shutdown.clone());
 
     let srv = server::Server::bind(&socket_path, worker)?;
     eprintln!("[failproofaid] listening on {}", socket_path.display());
 
     let run_result = srv.run_until(shutdown);
 
-    // Drain both background workers before returning. The collector gets a
-    // bounded budget rather than an unbounded join: process exit must not wait
-    // on a task that has wedged. Done before `?` so a server error still gets
-    // the collector a chance to flush instead of dropping buffered events.
-    if let Some(collector) = collector {
-        collector.join_with_flush(fpai_collect::DEFAULT_FLUSH_BUDGET);
-    }
+    // Join the manager, which drains the collector within its flush budget
+    // before returning. Done before `?` so a server error still gives the
+    // collector a chance to flush instead of dropping buffered events.
+    let _ = collector_mgr.join();
     let _ = cloud_monitor.join();
 
     run_result?;
@@ -128,6 +131,92 @@ fn run() -> Result<(), Box<dyn std::error::Error>> {
 /// serving the socket, because the CLI fails closed and a daemon that refused
 /// to boot over a malformed `ingest.json` would deny every tool call on the
 /// machine. The error is loud so it is fixable, not silent.
+/// Own the collector's lifecycle on a dedicated thread.
+///
+/// The collector config is not necessarily complete when the daemon starts:
+/// `failproofai config` installs the service, so the daemon comes up, and only
+/// THEN runs the connect step that writes `ingest.json` and the collector
+/// block. Resolving the config once at startup therefore left a freshly-set-up
+/// machine shipping nothing until the next manual restart — the exact confusion
+/// a user hit while testing.
+///
+/// This mirrors what the cloud-policy lane already does: it re-resolves its
+/// config every tick precisely so `--connect` needs no root (restarting a
+/// system unit does). The collector follows the same rule — it waits for the
+/// config to become enabled, then starts once. Enabling collection thus takes
+/// effect within one poll interval, no restart, no sudo.
+///
+/// It starts the collector once and does not tear it back down on a later
+/// `--disconnect` — that remains a restart, matching today's behaviour and
+/// avoiding a second start against the set-once health registry. The gap this
+/// closes is the common one: enabled *after* startup never taking effect.
+fn spawn_collector_manager(daemon_shutdown: Arc<AtomicBool>) -> std::thread::JoinHandle<()> {
+    let interval = collector_config_poll_interval();
+    std::thread::Builder::new()
+        .name("fpai-collect-mgr".to_string())
+        .spawn(move || {
+            // Wait until collection is enabled. A cheap config read each tick,
+            // not the full task build, so an incomplete config waits quietly
+            // rather than logging on every interval.
+            loop {
+                if daemon_shutdown.load(Ordering::Relaxed) {
+                    return;
+                }
+                if collector_is_enabled() {
+                    break;
+                }
+                let deadline = std::time::Instant::now() + interval;
+                while std::time::Instant::now() < deadline {
+                    if daemon_shutdown.load(Ordering::Relaxed) {
+                        return;
+                    }
+                    std::thread::sleep(Duration::from_millis(200));
+                }
+            }
+
+            // Enabled — build and start. `collector_tasks()` logs "collector
+            // enabled" once; `spawn_supervised` returns None only if the config
+            // flipped back to disabled between the check and the build, or the
+            // runtime failed to start.
+            let Some(collector) =
+                fpai_collect::spawn_supervised(collector_tasks(), daemon_shutdown.clone())
+            else {
+                return;
+            };
+
+            while !daemon_shutdown.load(Ordering::Relaxed) {
+                std::thread::sleep(Duration::from_millis(200));
+            }
+            collector.join_with_flush(fpai_collect::DEFAULT_FLUSH_BUDGET);
+        })
+        .expect("failed to spawn the collector manager thread")
+}
+
+/// Cheap "should the collector be running?" check — reads the two small config
+/// files. Any error resolves to `false`; the full `collector_tasks()` build
+/// logs the reason when it acts on an enabled config.
+fn collector_is_enabled() -> bool {
+    let Ok(home) = paths::failproofai_home() else {
+        return false;
+    };
+    fpai_collect::config::load(&home)
+        .map(|cfg| cfg.is_enabled())
+        .unwrap_or(false)
+}
+
+/// How often to re-check whether the collector config has become enabled.
+/// Short by default — it is two small JSON reads — so enabling collection after
+/// a fresh setup is prompt. `FAILPROOFAI_COLLECTOR_CONFIG_POLL_MS` overrides it.
+fn collector_config_poll_interval() -> Duration {
+    const DEFAULT_MS: u64 = 5_000;
+    const MINIMUM_MS: u64 = 500;
+    let ms = std::env::var("FAILPROOFAI_COLLECTOR_CONFIG_POLL_MS")
+        .ok()
+        .and_then(|v| v.parse::<u64>().ok())
+        .unwrap_or(DEFAULT_MS);
+    Duration::from_millis(ms.max(MINIMUM_MS))
+}
+
 fn collector_tasks() -> Vec<fpai_collect::TaskSpec> {
     let home = match paths::failproofai_home() {
         Ok(home) => home,
@@ -211,6 +300,7 @@ fn collector_tasks() -> Vec<fpai_collect::TaskSpec> {
         let spool_dir = cfg.own_spool_dir.clone();
         let verbosity = cfg.settings.hooks_verbosity;
         let environment = cfg.settings.environment.clone();
+        let machine_id = cfg.settings.machine_id.clone();
         tasks.push(fpai_collect::TaskSpec::new("hook-activity", move |sd| {
             fpai_collect::sources::hooks::run(
                 store_dir.clone(),
@@ -218,6 +308,7 @@ fn collector_tasks() -> Vec<fpai_collect::TaskSpec> {
                 spool_dir.clone(),
                 verbosity,
                 environment.clone(),
+                machine_id.clone(),
                 sd,
             )
         }));
@@ -232,6 +323,7 @@ fn collector_tasks() -> Vec<fpai_collect::TaskSpec> {
         // uses, so adding one is a row here plus its own module.
         let spool = cfg.own_spool_dir.clone();
         let env = cfg.settings.environment.clone();
+        let machine = cfg.settings.machine_id.clone();
         let cursors = home.join("cursors");
 
         use fpai_collect::sources::{claude, codex, copilot, openclaw, pi};
@@ -244,6 +336,7 @@ fn collector_tasks() -> Vec<fpai_collect::TaskSpec> {
             &spool,
             &cursors,
             &env,
+            machine.as_deref(),
         );
         // Subagent transcripts live under the SAME root, claimed by a second
         // format. A separate source, not a second predicate: `is_source_file`
@@ -259,6 +352,7 @@ fn collector_tasks() -> Vec<fpai_collect::TaskSpec> {
             &spool,
             &cursors,
             &env,
+            machine.as_deref(),
         );
         file_source(
             &mut tasks,
@@ -269,6 +363,7 @@ fn collector_tasks() -> Vec<fpai_collect::TaskSpec> {
             &spool,
             &cursors,
             &env,
+            machine.as_deref(),
         );
         file_source(
             &mut tasks,
@@ -279,6 +374,7 @@ fn collector_tasks() -> Vec<fpai_collect::TaskSpec> {
             &spool,
             &cursors,
             &env,
+            machine.as_deref(),
         );
         file_source(
             &mut tasks,
@@ -289,6 +385,7 @@ fn collector_tasks() -> Vec<fpai_collect::TaskSpec> {
             &spool,
             &cursors,
             &env,
+            machine.as_deref(),
         );
         file_source(
             &mut tasks,
@@ -299,6 +396,7 @@ fn collector_tasks() -> Vec<fpai_collect::TaskSpec> {
             &spool,
             &cursors,
             &env,
+            machine.as_deref(),
         );
 
         use fpai_collect::sources::{goose, hermes, opencode};
@@ -311,6 +409,7 @@ fn collector_tasks() -> Vec<fpai_collect::TaskSpec> {
             &spool,
             cursors.join("goose"),
             &env,
+            machine.as_deref(),
         );
         sqlite_source(
             &mut tasks,
@@ -321,6 +420,7 @@ fn collector_tasks() -> Vec<fpai_collect::TaskSpec> {
             &spool,
             cursors.join("opencode"),
             &env,
+            machine.as_deref(),
         );
 
         // Hermes profiles are SEPARATE databases, and the SQLite poller keys its
@@ -338,6 +438,7 @@ fn collector_tasks() -> Vec<fpai_collect::TaskSpec> {
                 &spool,
                 state,
                 &env,
+                machine.as_deref(),
             );
         }
     }
@@ -389,6 +490,7 @@ fn file_source(
     spool_dir: &std::path::Path,
     cursor_root: &std::path::Path,
     environment: &str,
+    machine_id: Option<&str>,
 ) {
     let spool_dir = spool_dir.to_path_buf();
     // One cursor store per source, never shared: the store writes its whole map
@@ -396,6 +498,7 @@ fn file_source(
     // loser would re-read from zero after every restart.
     let state_dir = cursor_root.join(name);
     let environment = environment.to_string();
+    let machine_id = machine_id.map(str::to_string);
     tasks.push(fpai_collect::TaskSpec::new(name, move |sd| {
         fpai_collect::filetail::run(
             fpai_collect::filetail::Spec {
@@ -407,6 +510,7 @@ fn file_source(
                 params: fpai_collect::filetail::Params {
                     agent_id: default_agent_id.to_string(),
                     environment: environment.clone(),
+                    machine_id: machine_id.clone(),
                     end_idle_mins: 10,
                     max_read_bytes: 32 * 1024 * 1024,
                     max_batch_bytes: fpai_collect::spool::DEFAULT_MAX_BATCH_BYTES,
@@ -432,9 +536,11 @@ fn sqlite_source(
     spool_dir: &std::path::Path,
     state_dir: std::path::PathBuf,
     environment: &str,
+    machine_id: Option<&str>,
 ) {
     let spool_dir = spool_dir.to_path_buf();
     let environment = environment.to_string();
+    let machine_id = machine_id.map(str::to_string);
     tasks.push(fpai_collect::TaskSpec::new(name, move |sd| {
         fpai_collect::sqlitepoll::run(
             fpai_collect::sqlitepoll::Spec {
@@ -446,6 +552,7 @@ fn sqlite_source(
                 params: fpai_collect::sqlitepoll::Params {
                     agent_id: default_agent_id.to_string(),
                     environment: environment.clone(),
+                    machine_id: machine_id.clone(),
                     max_rows_per_poll: 2000,
                     max_batch_bytes: fpai_collect::spool::DEFAULT_MAX_BATCH_BYTES,
                     max_drain_passes: 20,

package/.next/standalone/crates/fpai-collect/src/config.rs

@@ -117,6 +117,13 @@ pub struct Settings {
     /// here would silently drop every event this machine produced.
     #[serde(default = "default_environment")]
     pub environment: String,
+    /// The id of the machine this daemon runs on, written by
+    /// `failproofai config --connect --machine-id <id>`. Stamped on every
+    /// collected event so the server groups by machine rather than by
+    /// `agent_id` (a per-project identity). Absent on config written before
+    /// this field existed; such events carry no machine.
+    #[serde(default, rename = "machineId")]
+    pub machine_id: Option<String>,
 }
 
 fn default_true() -> bool {
@@ -135,6 +142,7 @@ impl Default for Settings {
             hooks_verbosity: HooksVerbosity::default(),
             redact: Redact::default(),
             environment: default_environment(),
+            machine_id: None,
         }
     }
 }

package/.next/standalone/crates/fpai-collect/src/filetail.rs

@@ -130,6 +130,8 @@ pub fn no_seed_state(_lines: &[String], _state: &mut TailState) {}
 pub struct Params {
     pub agent_id: String,
     pub environment: String,
+    /// Machine this daemon runs on, stamped on every event. See `SpoolWriter`.
+    pub machine_id: Option<String>,
     /// Minutes a file must be idle at EOF before `agent_end` is emitted.
     pub end_idle_mins: u64,
     pub max_read_bytes: u64,
@@ -248,7 +250,8 @@ async fn process_file(
         spec.params.max_batch_bytes,
         spec.format.kind,
         &ctx.session_id,
-    );
+    )
+    .with_machine_id(spec.params.machine_id.clone());
     let mut emitted = 0u64;
 
     // A session with no start event never appears in the product, so retry it

package/.next/standalone/crates/fpai-collect/src/sources/hooks/mod.rs

@@ -81,6 +81,7 @@ pub async fn run(
     spool_dir: PathBuf,
     verbosity: HooksVerbosity,
     environment: String,
+    machine_id: Option<String>,
     sd: Shutdown,
 ) -> Result<(), TaskError> {
     if verbosity == HooksVerbosity::Off {
@@ -108,6 +109,7 @@ pub async fn run(
             &mut cursors,
             verbosity,
             &environment,
+            machine_id.as_deref(),
         )
         .await
         {
@@ -138,6 +140,7 @@ async fn poll_once(
     cursors: &mut CursorStore,
     verbosity: HooksVerbosity,
     environment: &str,
+    machine_id: Option<&str>,
 ) -> Result<u64, TaskError> {
     let files = list_pages(store_dir).await;
     if files.is_empty() {
@@ -149,7 +152,8 @@ async fn poll_once(
         DEFAULT_MAX_BATCH_BYTES,
         "hooks",
         "activity",
-    );
+    )
+    .with_machine_id(machine_id.map(str::to_string));
     // Allow rows are rolled up across the whole pass, so a bucket spanning two
     // files still emits once.
     let mut buckets: BTreeMap<transform::BucketKey, AllowBucket> = BTreeMap::new();

package/.next/standalone/crates/fpai-collect/src/spool.rs

@@ -56,6 +56,14 @@ pub struct SpoolWriter {
     buf_bytes: u64,
     redact: Redact,
     redacted: u64,
+    /// The machine this daemon runs on, stamped on every event so the server
+    /// can tell one machine from another. Without it, events carry only
+    /// `agent_id` — a per-project/per-harness identity — and the fleet views
+    /// mistake every project for a separate machine. `None` on a machine that
+    /// was never enrolled with a machine id (older config); such events simply
+    /// carry no machine and are excluded from machine-level counts rather than
+    /// guessed into one.
+    machine_id: Option<String>,
 }
 
 impl SpoolWriter {
@@ -84,6 +92,7 @@ impl SpoolWriter {
             // which is the safe direction for the mistake to fall.
             redact: Redact::Minimal,
             redacted: 0,
+            machine_id: None,
         }
     }
 
@@ -95,6 +104,13 @@ impl SpoolWriter {
         self
     }
 
+    /// Set the machine id stamped on every event. An empty string is treated as
+    /// absent, so a misconfigured blank id never becomes a machine of its own.
+    pub fn with_machine_id(mut self, id: Option<String>) -> Self {
+        self.machine_id = id.filter(|s| !s.is_empty());
+        self
+    }
+
     /// How many string leaves have been scrubbed. Reported without ever
     /// logging what was removed.
     pub fn redacted_count(&self) -> u64 {
@@ -117,6 +133,17 @@ impl SpoolWriter {
         // disk.
         self.redacted += crate::redact::scrub_value(&mut event, self.redact) as u64;
 
+        // Stamp the machine id here, at the one point every event passes
+        // through — a source cannot forget it and a new source inherits it. Set
+        // only when absent, so an event that already names its machine (a
+        // re-shipped batch, say) is never overwritten.
+        if let Some(id) = &self.machine_id
+            && let Some(obj) = event.as_object_mut()
+        {
+            obj.entry("machine_id")
+                .or_insert_with(|| Value::String(id.clone()));
+        }
+
         let mut line = serialize(&event)?;
 
         if line.len() as u64 > self.max_batch_bytes {
@@ -430,6 +457,56 @@ mod tests {
         std::fs::remove_dir_all(&dir).ok();
     }
 
+    #[tokio::test]
+    async fn machine_id_is_stamped_on_every_event_when_set() {
+        // Without this the server can only group by agent_id — a per-project
+        // identity — so one machine's many projects each read as a machine.
+        let dir = tmpdir("machine-id");
+        let mut w = SpoolWriter::new(dir.clone(), DEFAULT_MAX_BATCH_BYTES, "claude", "s")
+            .with_machine_id(Some("beta-test".into()));
+        w.push(json!({"type": "agent_start", "agent_id": "claude-foo"}))
+            .await
+            .unwrap();
+        w.flush().await.unwrap();
+        let name = batches(&dir).remove(0);
+        let body = std::fs::read_to_string(dir.join(&name)).unwrap();
+        assert!(body.contains(r#""machine_id":"beta-test""#), "got {body}");
+        std::fs::remove_dir_all(&dir).ok();
+    }
+
+    #[tokio::test]
+    async fn an_absent_machine_id_stamps_nothing() {
+        // A machine that was never given an id must not invent one — the server
+        // excludes machine-less events rather than bucket them.
+        let dir = tmpdir("no-machine-id");
+        let mut w = SpoolWriter::new(dir.clone(), DEFAULT_MAX_BATCH_BYTES, "claude", "s");
+        w.push(json!({"type": "agent_start"})).await.unwrap();
+        w.flush().await.unwrap();
+        let name = batches(&dir).remove(0);
+        assert!(
+            !std::fs::read_to_string(dir.join(&name))
+                .unwrap()
+                .contains("machine_id")
+        );
+        std::fs::remove_dir_all(&dir).ok();
+    }
+
+    #[tokio::test]
+    async fn an_empty_machine_id_is_treated_as_absent() {
+        let dir = tmpdir("blank-machine-id");
+        let mut w = SpoolWriter::new(dir.clone(), DEFAULT_MAX_BATCH_BYTES, "claude", "s")
+            .with_machine_id(Some(String::new()));
+        w.push(json!({"type": "agent_start"})).await.unwrap();
+        w.flush().await.unwrap();
+        let name = batches(&dir).remove(0);
+        assert!(
+            !std::fs::read_to_string(dir.join(&name))
+                .unwrap()
+                .contains("machine_id")
+        );
+        std::fs::remove_dir_all(&dir).ok();
+    }
+
     #[tokio::test]
     async fn redaction_can_be_turned_off() {
         let dir = tmpdir("redact-off");

package/.next/standalone/crates/fpai-collect/src/sqlitepoll.rs

@@ -106,6 +106,8 @@ pub struct SqliteFormat {
 pub struct Params {
     pub agent_id: String,
     pub environment: String,
+    /// Machine this daemon runs on, stamped on every event. See `SpoolWriter`.
+    pub machine_id: Option<String>,
     pub max_rows_per_poll: u64,
     pub max_batch_bytes: u64,
     /// Poll passes before yielding to the shutdown check. Bounds how long a
@@ -214,7 +216,8 @@ async fn poll_once(spec: &Spec, cursors: &mut CursorStore) -> Result<(u64, bool)
         spec.params.max_batch_bytes,
         spec.format.kind,
         spec.format.kind,
-    );
+    )
+    .with_machine_id(spec.params.machine_id.clone());
     let emitted = outcome.events.len() as u64;
     for event in outcome.events {
         writer.push(event).await.map_err(io_err)?;

package/.next/standalone/crates/fpai-collect/tests/claude_source.rs

@@ -505,6 +505,7 @@ fn spec(root: PathBuf, spool: PathBuf, state: PathBuf) -> Spec {
         params: Params {
             agent_id: claude::DEFAULT_AGENT_ID.into(),
             environment: "local".into(),
+            machine_id: None,
             end_idle_mins: 0, // end immediately, so the test need not wait
             max_read_bytes: 8 * 1024 * 1024,
             max_batch_bytes: 8 * 1024 * 1024,

package/.next/standalone/crates/fpai-collect/tests/claude_subagents.rs

@@ -268,6 +268,7 @@ fn spec(root: PathBuf, spool: PathBuf, state: PathBuf) -> Spec {
         params: Params {
             agent_id: claude::SUBAGENT_DEFAULT_AGENT_ID.into(),
             environment: "local".into(),
+            machine_id: None,
             end_idle_mins: 0,
             max_read_bytes: 8 * 1024 * 1024,
             max_batch_bytes: 8 * 1024 * 1024,

package/.next/standalone/crates/fpai-collect/tests/codex_source.rs

@@ -725,6 +725,7 @@ fn spec(root: PathBuf, spool: PathBuf, state: PathBuf) -> Spec {
         params: Params {
             agent_id: codex::DEFAULT_AGENT_ID.into(),
             environment: "local".into(),
+            machine_id: None,
             end_idle_mins: 0, // end immediately, so the test need not wait
             max_read_bytes: 8 * 1024 * 1024,
             max_batch_bytes: 8 * 1024 * 1024,

package/.next/standalone/crates/fpai-collect/tests/copilot_source.rs

@@ -771,6 +771,7 @@ fn spec(root: PathBuf, spool: PathBuf, state: PathBuf) -> Spec {
         params: Params {
             agent_id: copilot::DEFAULT_AGENT_ID.into(),
             environment: "local".into(),
+            machine_id: None,
             end_idle_mins: 0, // end immediately, so the test need not wait
             max_read_bytes: 8 * 1024 * 1024,
             max_batch_bytes: 8 * 1024 * 1024,

package/.next/standalone/crates/fpai-collect/tests/goose_source.rs

@@ -871,6 +871,7 @@ fn spec(db: &Path, spool: PathBuf, state: PathBuf) -> Spec {
         params: Params {
             agent_id: goose::DEFAULT_AGENT_ID.into(),
             environment: "local".into(),
+            machine_id: None,
             max_rows_per_poll: 500,
             max_batch_bytes: 8 * 1024 * 1024,
             max_drain_passes: 8,

package/.next/standalone/crates/fpai-collect/tests/hermes_source.rs

@@ -993,6 +993,7 @@ fn spec(db: PathBuf, spool: PathBuf, state: PathBuf) -> sqlitepoll::Spec {
         params: sqlitepoll::Params {
             agent_id: hermes::DEFAULT_AGENT_ID.into(),
             environment: "local".into(),
+            machine_id: None,
             max_rows_per_poll: 500,
             max_batch_bytes: 8 * 1024 * 1024,
             max_drain_passes: 8,

package/.next/standalone/crates/fpai-collect/tests/hooks_source.rs

@@ -95,6 +95,7 @@ async fn run_once(store: &Path, state: &Path, spool: &Path, v: HooksVerbosity) {
         spool.to_path_buf(),
         v,
         "local".into(),
+        None,
         sd,
     );
     let _ = tokio::time::timeout(Duration::from_millis(1500), fut).await;

package/.next/standalone/crates/fpai-collect/tests/openclaw_source.rs

@@ -573,6 +573,7 @@ fn spec(base: PathBuf, spool: PathBuf, state: PathBuf) -> Spec {
         params: Params {
             agent_id: openclaw::DEFAULT_AGENT_ID.into(),
             environment: "local".into(),
+            machine_id: None,
             end_idle_mins: 0, // end immediately, so the test need not wait
             max_read_bytes: 8 * 1024 * 1024,
             max_batch_bytes: 8 * 1024 * 1024,

package/.next/standalone/crates/fpai-collect/tests/pi_source.rs

@@ -780,6 +780,7 @@ fn spec(root: PathBuf, spool: PathBuf, state: PathBuf) -> Spec {
         params: Params {
             agent_id: pi::DEFAULT_AGENT_ID.into(),
             environment: "local".into(),
+            machine_id: None,
             end_idle_mins: 0, // end immediately, so the test need not wait
             max_read_bytes: 8 * 1024 * 1024,
             max_batch_bytes: 8 * 1024 * 1024,

package/.next/standalone/package.json

@@ -1,6 +1,6 @@
 {
   "name": "failproofai",
-  "version": "1.0.0-beta.3",
+  "version": "1.0.0-beta.5",
   "description": "The easiest way to manage policies that keep your AI agents reliable, on-task, and running autonomously — for Claude Code & the Agents SDK",
   "bin": {
     "failproofai": "./dist/cli.mjs",
@@ -76,19 +76,19 @@
     "@anthropic-ai/sdk": "^0.115.0",
     "@mdx-js/mdx": "^3.1.1",
     "@tailwindcss/postcss": "^4.3.1",
-    "@tanstack/react-virtual": "^3.14.3",
+    "@tanstack/react-virtual": "^3.14.9",
     "@testing-library/jest-dom": "^7.0.0",
     "@testing-library/react": "^16.3.2",
     "@testing-library/user-event": "^14.6.1",
-    "@types/node": "26.1.1",
+    "@types/node": "26.1.2",
     "@types/react": "19.2.17",
     "@types/react-dom": "^19.2.3",
-    "@vitejs/plugin-react": "^6.0.1",
+    "@vitejs/plugin-react": "^6.0.5",
     "clsx": "^2.1.1",
     "eslint": "^10.5.0",
     "eslint-config-next": "^16.2.9",
-    "jsdom": "^30.0.0",
-    "lucide-react": "^1.18.0",
+    "jsdom": "^30.0.1",
+    "lucide-react": "^1.28.0",
     "next": "^16.2.11",
     "react": "^19.2.4",
     "react-dom": "^19.2.4",
@@ -100,7 +100,7 @@
   "dependencies": {
     "html-to-image": "^1.11.13",
     "html2canvas": "^1.4.1",
-    "posthog-node": "^5.37.1",
+    "posthog-node": "^5.47.7",
     "sql.js": "^1.14.1",
     "yaml": "^2.9.0"
   },
@@ -108,8 +108,14 @@
     "postcss": "8.5.23",
     "eslint-plugin-react-hooks": "7.0.1",
     "vite": "8.0.16",
-    "undici": "7.28.0",
+    "undici": "7.29.0",
     "brace-expansion": "5.0.9",
     "sharp": "0.35.0"
+  },
+  "optionalDependencies": {
+    "@failproofai/failproofaid-linux-x64": "1.0.0-beta.5",
+    "@failproofai/failproofaid-linux-arm64": "1.0.0-beta.5",
+    "@failproofai/failproofaid-darwin-x64": "1.0.0-beta.5",
+    "@failproofai/failproofaid-darwin-arm64": "1.0.0-beta.5"
   }
 }