feat(storage): cron and flows on the storage ports

crates/openhuman-cli/Cargo.toml

@@ -93,6 +93,11 @@ path = "../../tests/storage_approvals_e2e.rs"
 name = "storage_domains_e2e"
 path = "../../tests/storage_domains_e2e.rs"
 
+[[test]]
+# Its own binary: it installs a storage backend into the process-wide slot.
+name = "storage_flows_e2e"
+path = "../../tests/storage_flows_e2e.rs"
+
 [[test]]
 # Its own binary: it installs a storage backend into the process-wide slot and
 # sets the keyring master-key environment.

crates/openhuman-core/Cargo.toml

@@ -81,6 +81,11 @@ tinyflows-catalog = { path = "../../vendor/tinyflows/crates/tinyflows-catalog",
 # The cron job/run store half (`schedule`) is unconditional, so `tinyflows-sqlite`
 # is too; only its `catalog` half (which needs the engine) rides the `flows` gate.
 tinyflows-sqlite = { path = "../../vendor/tinyflows/crates/tinyflows-sqlite", default-features = false, features = ["schedule"] }
+# tinyflows' stores on the storage ports, used instead of the SQLite files when
+# a storage backend is configured (`storage`). The cron half (`schedule`) is
+# unconditional like cron itself; the catalog, flow state and checkpointer
+# (`catalog`, which needs the engine) ride the `flows` gate.
+tinyflows-drivers = { path = "../../vendor/tinyflows/crates/tinyflows-drivers", default-features = false, features = ["schedule"] }
 # The authoring copilot's words: the `workflow_builder` / `flow_discovery`
 # standing archetypes and the turn brief that opens a builder turn. Harness-free
 # by construction — it names no tool trait and no model client — so this host
@@ -147,6 +152,7 @@ tinyagents-definition = { path = "../../vendor/tinyagents/crates/tinyagents-defi
 tinyagents-live = { path = "../../vendor/tinyagents/crates/tinyagents-live", optional = true }
 tinyagents-graph = { path = "../../vendor/tinyagents/crates/tinyagents-graph", features = [
     "sqlite",
+    "storage-drivers",
 ] }
 tinyagents-registry = { path = "../../vendor/tinyagents/crates/tinyagents-registry" }
 tinyagents-session = { path = "../../vendor/tinyagents/crates/tinyagents-session", features = ["storage-drivers"] }
@@ -632,6 +638,9 @@ tinymemory-api = { path = "../../vendor/tinymemory/crates/tinymemory-api", featu
 # write path can produce. Declared here rather than in `[dependencies]` so the
 # shipped binary never carries those two writers.
 tinyflows-sqlite = { path = "../../vendor/tinyflows/crates/tinyflows-sqlite", features = ["test-fixtures"] }
+# The document catalog's `*_for_test` fixtures, which the flows store forwards
+# in test builds.
+tinyflows-drivers = { path = "../../vendor/tinyflows/crates/tinyflows-drivers", default-features = false, features = ["schedule", "test-fixtures"] }
 # Test fixtures derive a known account from the BIP-39 vector phrase. Production
 # does not derive at all — see the note on the main `tinywallet` entry. Cargo
 # does not link dev-dependency features into the shipped binary, so enabling
@@ -914,7 +923,7 @@ media = ["tinyagents-harness/media"]
 # runtime `DomainSet::flows` flag (#4796): the feature narrows the compile-time
 # surface, `DomainSet` gates it at runtime.
 # NOTE: this gate does NOT drop `tinyagents` itself — 26+ domains consume it.
-flows = ["dep:tinyflows", "dep:tinyflows-catalog", "dep:tinyflows-copilot", "tinyflows-sqlite/catalog"]
+flows = ["dep:tinyflows", "dep:tinyflows-catalog", "dep:tinyflows-copilot", "tinyflows-drivers/catalog", "tinyflows-sqlite/catalog"]
 # Skills domains: `openhuman::skills` (metadata/discovery/install),
 # `openhuman::skill_runtime` (SKILL.md execution + the skill_executor agent),
 # and `openhuman::skill_registry` (remote catalogs + the skill_setup agent).

crates/openhuman-core/src/agent/orchestration/delegation.rs

@@ -81,11 +81,26 @@ pub(crate) async fn run_subagent_delegation_with_parent_context(
     // durable graphs simply expire (orphaned tasks are reconciled at boot per
     // 07.2). Checkpoint metadata (thread/checkpoint/parent/run ids) stays
     // inspectable through the crate `Checkpointer` API.
-    let checkpoint_db = config.workspace_dir.join("graph_checkpoints.db");
-    let checkpointer: Arc<dyn Checkpointer<DelegationState>> = Arc::new(
-        SqliteCheckpointer::<DelegationState>::open(&checkpoint_db)
-            .map_err(|e| format!("open durable graph checkpoint store: {e}"))?,
-    );
+    //
+    // With a storage backend configured (`crate::storage`) the checkpoints
+    // live there instead, in the acting agent's scope.
+    let checkpointer: Arc<dyn Checkpointer<DelegationState>> =
+        match crate::storage::current_scoped()
+            .map_err(|e| format!("resolve the storage scope for graph checkpoints: {e}"))?
+        {
+            Some(scoped) => Arc::new(tinyagents_graph::checkpoint::DriverCheckpointer::<
+                DelegationState,
+            >::with_prefix(
+                Arc::clone(scoped.documents()), "delegation_graph"
+            )),
+            None => {
+                let checkpoint_db = config.workspace_dir.join("graph_checkpoints.db");
+                Arc::new(
+                    SqliteCheckpointer::<DelegationState>::open(&checkpoint_db)
+                        .map_err(|e| format!("open durable graph checkpoint store: {e}"))?,
+                )
+            }
+        };
 
     tracing::info!(
         target: LOG_TARGET,

crates/openhuman-core/src/cron/README.md

@@ -231,6 +231,16 @@ missing row, reschedules a drifted one, and removes the retired
 `memory_context_refresh` row. It runs from [`core/runtime/services.rs`](../core/runtime/services.rs) and from
 [`security/credentials/ops/user_scope.rs`](../security/credentials/ops/user_scope.rs).
 
+### On a storage backend
+
+With a storage backend configured (`OPENHUMAN_STORAGE_URL` / `[storage] url`,
+see `crate::storage`), every `store` function is served by
+`tinyflows_drivers::schedule::CronDocuments` instead of `cron/jobs.db`: the
+same jobs and runs on the document port, in the acting agent's storage scope,
+with the same history cap and due-job batch size. `reschedule_after_run`
+advances a job only if its stored schedule still matches the job that fired,
+so two processes sharing one database don't double-advance it.
+
 ## Layout
 
 | Path | What it does |