use std::path::Path;
use std::sync::Mutex;
use std::time::Instant;
use agentstategraph_core::{
Commit, Epoch, EpochScope, EpochStatus, IntentCategory, Namespace, Node, Object, ObjectId,
Session, SessionStatus, TAG_GIT_REVISION, TAG_PIN_STATE,
};
use agentstategraph_reminders::{
Reminder, ReminderError, ReminderFilter, ReminderStore,
types::{Priority, ReminderStatus},
};
use agentstategraph_taint::{Taint, TaintEffect, TaintKind, TaintMetadata, TaintSeverity};
use chrono::{DateTime, Utc};
use rusqlite::{Connection, OptionalExtension, Row, params};
use crate::traits::{
CommitStore, CommitTrace, DEFAULT_GC_GRACE, EpochStore, GC_FRESHEN_AFTER, GcReachability,
GcSweep, HISTORY_NAMESPACE_UNKNOWN, HistoryMilestoneRow, HistoryRollupRow, ObjectStore,
RefStore, SessionStore, StorageError, StoreShape, StoreTotals, TableBytes, TaintStore,
VacuumStats,
};
pub struct SqliteStorage {
conn: Mutex<Connection>,
path: Option<std::path::PathBuf>,
gc_conn: Mutex<Option<Connection>>,
gc_grace: std::time::Duration,
}
impl SqliteStorage {
pub fn open(path: impl AsRef<Path>) -> Result<Self, StorageError> {
let path = path.as_ref().to_path_buf();
let conn = Connection::open(&path)
.map_err(|e| StorageError::Backend(format!("sqlite open: {}", e)))?;
oxtel_sql::rusqlite::instrument(&conn);
let _ = conn.query_row("PRAGMA auto_vacuum=INCREMENTAL", [], |r| r.get::<_, i64>(0));
let _ = conn.query_row("PRAGMA journal_mode=WAL", [], |r| r.get::<_, String>(0));
let _ = conn.pragma_update(None, "synchronous", "NORMAL");
let _ = conn.busy_timeout(std::time::Duration::from_secs(5));
let storage = Self {
conn: Mutex::new(conn),
path: Some(path),
gc_conn: Mutex::new(None),
gc_grace: DEFAULT_GC_GRACE,
};
storage.init_tables()?;
describe_connection_metrics();
Ok(storage)
}
pub fn in_memory() -> Result<Self, StorageError> {
let conn = Connection::open_in_memory()
.map_err(|e| StorageError::Backend(format!("sqlite open: {}", e)))?;
oxtel_sql::rusqlite::instrument(&conn);
let storage = Self {
conn: Mutex::new(conn),
path: None,
gc_conn: Mutex::new(None),
gc_grace: DEFAULT_GC_GRACE,
};
storage.init_tables()?;
describe_connection_metrics();
Ok(storage)
}
pub fn with_gc_grace(mut self, grace: std::time::Duration) -> Self {
self.gc_grace = grace;
self
}
fn init_tables(&self) -> Result<(), StorageError> {
let conn = self
.conn
.lock()
.map_err(|e| StorageError::Backend(e.to_string()))?;
conn.execute_batch(
"
-- `written_at` (Unix milliseconds) is when the object was last
-- stored; a GC sweep spares recent ones. See with_gc_grace.
CREATE TABLE IF NOT EXISTS objects (
id BLOB PRIMARY KEY,
data BLOB NOT NULL,
written_at INTEGER NOT NULL DEFAULT 0
);
CREATE TABLE IF NOT EXISTS commits (
id BLOB PRIMARY KEY,
data BLOB NOT NULL,
timestamp TEXT NOT NULL
);
-- The trace each commit was made in (Plan H t-009): beside the
-- commit, not in it, so commit ids don't depend on telemetry.
CREATE TABLE IF NOT EXISTS commit_traces (
commit_id BLOB PRIMARY KEY,
trace_id TEXT NOT NULL,
span_id TEXT NOT NULL
);
CREATE TABLE IF NOT EXISTS namespaces (
name TEXT PRIMARY KEY,
created_at TEXT NOT NULL
);
CREATE TABLE IF NOT EXISTS refs (
namespace TEXT NOT NULL,
name TEXT NOT NULL,
target BLOB NOT NULL,
PRIMARY KEY (namespace, name)
);
CREATE TABLE IF NOT EXISTS epochs (
id TEXT PRIMARY KEY,
description TEXT NOT NULL DEFAULT '',
status TEXT NOT NULL DEFAULT 'Active',
created_at TEXT NOT NULL,
sealed_at TEXT,
summary TEXT,
root_intents TEXT NOT NULL DEFAULT '[]',
agents TEXT NOT NULL DEFAULT '[]',
tags TEXT NOT NULL DEFAULT '[]',
commit_count INTEGER NOT NULL DEFAULT 0,
sealed_commits TEXT NOT NULL DEFAULT '[]',
seal_hash BLOB,
namespace TEXT,
scope TEXT NOT NULL DEFAULT 'all'
);
CREATE TABLE IF NOT EXISTS sessions (
id TEXT PRIMARY KEY,
agent_id TEXT NOT NULL,
parent_id TEXT REFERENCES sessions(id),
scope_path TEXT,
scope_branch TEXT,
scope_namespace TEXT,
status TEXT NOT NULL DEFAULT 'Active',
created_at TEXT NOT NULL,
ended_at TEXT,
metadata TEXT NOT NULL DEFAULT '{}',
commit_count INTEGER NOT NULL DEFAULT 0
);
CREATE TABLE IF NOT EXISTS taints (
id TEXT PRIMARY KEY,
path TEXT NOT NULL,
name TEXT NOT NULL,
kind TEXT NOT NULL,
effect TEXT NOT NULL,
severity TEXT NOT NULL DEFAULT 'medium',
reason TEXT NOT NULL,
agent_id TEXT NOT NULL,
commit_id TEXT NOT NULL DEFAULT '',
created_at TEXT NOT NULL,
expires_at TEXT,
resolved_at TEXT,
resolved_by TEXT,
resolved_reason TEXT,
resolved_proof TEXT,
propagate INTEGER NOT NULL DEFAULT 1,
metadata TEXT NOT NULL DEFAULT '{}'
);
CREATE TABLE IF NOT EXISTS reminders (
id TEXT PRIMARY KEY,
title TEXT NOT NULL,
instructions TEXT NOT NULL,
commands TEXT NOT NULL DEFAULT '[]',
refs TEXT NOT NULL DEFAULT '[]',
priority INTEGER NOT NULL DEFAULT 3,
due_at TEXT NOT NULL,
schedule TEXT,
autonomous INTEGER NOT NULL DEFAULT 1,
created_by TEXT NOT NULL,
created_at TEXT NOT NULL,
status TEXT NOT NULL DEFAULT 'pending',
snoozed_until TEXT,
executions TEXT NOT NULL DEFAULT '[]',
tags TEXT NOT NULL DEFAULT '[]'
);
CREATE INDEX IF NOT EXISTS idx_commits_timestamp ON commits(timestamp DESC);
-- Leaf-value index (plan perf-slow-endpoints t-006). Turns value
-- search from a full tree walk into a trigram substring probe.
-- Keyed by (namespace, ref) and maintained IN PLACE as a ref
-- advances: a one-time backfill on first use, then incremental
-- add/remove of only the leaves a commit changed.
--
-- `leaf_rows` is the base table (real indexes for the ns/ref filter
-- and for incremental delete-by-path); `leaf_fts` is a trigram FTS5
-- external-content index over `value`, kept in sync by triggers;
-- `leaf_index_refs` records which (namespace, ref) sets are built.
CREATE TABLE IF NOT EXISTS leaf_rows (
id INTEGER PRIMARY KEY,
namespace TEXT NOT NULL,
ref TEXT NOT NULL,
path TEXT NOT NULL,
value TEXT NOT NULL
);
CREATE INDEX IF NOT EXISTS idx_leaf_rows_nsref
ON leaf_rows(namespace, ref);
CREATE INDEX IF NOT EXISTS idx_leaf_rows_nsrefpath
ON leaf_rows(namespace, ref, path);
CREATE VIRTUAL TABLE IF NOT EXISTS leaf_fts USING fts5(
value, content='leaf_rows', content_rowid='id', tokenize='trigram'
);
CREATE TRIGGER IF NOT EXISTS leaf_rows_ai AFTER INSERT ON leaf_rows BEGIN
INSERT INTO leaf_fts(rowid, value) VALUES (new.id, new.value);
END;
CREATE TRIGGER IF NOT EXISTS leaf_rows_ad AFTER DELETE ON leaf_rows BEGIN
INSERT INTO leaf_fts(leaf_fts, rowid, value) VALUES ('delete', old.id, old.value);
END;
-- `root` is the state root the set reflects (NULL when unknown),
-- so a diff applies only to the tree it was computed from.
CREATE TABLE IF NOT EXISTS leaf_index_refs (
namespace TEXT NOT NULL,
ref TEXT NOT NULL,
root BLOB,
PRIMARY KEY (namespace, ref)
);
-- Roots of uncommitted work (open speculations) that a GC sweep
-- must keep, from any process sharing this file. See gc_pin_root.
CREATE TABLE IF NOT EXISTS gc_pending_roots (
key TEXT PRIMARY KEY,
root BLOB NOT NULL,
updated_at INTEGER NOT NULL
);
CREATE INDEX IF NOT EXISTS idx_epochs_status ON epochs(status);
CREATE INDEX IF NOT EXISTS idx_sessions_agent ON sessions(agent_id);
CREATE INDEX IF NOT EXISTS idx_taints_path ON taints(path);
CREATE INDEX IF NOT EXISTS idx_taints_kind ON taints(kind);
CREATE UNIQUE INDEX IF NOT EXISTS idx_taints_unique_active
ON taints(path, name, kind) WHERE resolved_at IS NULL;
CREATE INDEX IF NOT EXISTS idx_reminders_status ON reminders(status);
CREATE INDEX IF NOT EXISTS idx_reminders_due_at ON reminders(due_at);
CREATE INDEX IF NOT EXISTS idx_reminders_priority ON reminders(priority);
CREATE INDEX IF NOT EXISTS idx_reminders_created_by ON reminders(created_by);
-- Plan A t-001: distilled project-history metrics. Populated
-- incrementally by `history_extract_batch` from the commit chain,
-- keyed off the monotonic `commits.rowid` cursor stored in
-- asg_history_meta. Derived, rebuildable — never authoritative.
CREATE TABLE IF NOT EXISTS asg_history_meta (
key TEXT PRIMARY KEY,
value TEXT NOT NULL
);
-- Commit-history rollup: one row per (day, namespace, agent,
-- intent category). Collapses velocity + authorship + intent-mix
-- into an indexed table instead of a 512k-row commit scan.
CREATE TABLE IF NOT EXISTS asg_history_commit_rollup (
day TEXT NOT NULL,
namespace TEXT NOT NULL,
agent_id TEXT NOT NULL,
intent_category TEXT NOT NULL,
commit_count INTEGER NOT NULL DEFAULT 0,
first_ts TEXT NOT NULL,
last_ts TEXT NOT NULL,
PRIMARY KEY (day, namespace, agent_id, intent_category)
);
CREATE INDEX IF NOT EXISTS idx_asg_history_rollup_day
ON asg_history_commit_rollup(day);
-- Milestone timeline: the human-meaningful spine — every
-- `Checkpoint` commit (epoch/session boundaries land here in a
-- later task). One row per (commit, kind); insert-or-ignore keeps
-- re-extraction idempotent. `state_root` (Plan A t-005) is the
-- retention hook: it names the snapshot a milestone preserves, so
-- Plan B's GC can keep milestone state reachable while pruning
-- everything else. It is written only when the intent opts in with
-- `TAG_PIN_STATE`, because pinning every checkpoint retains one full
-- state tree per routine re-index and leaves nothing reclaimable.
-- `git_sha` (from `TAG_GIT_REVISION`) records the revision behind an
-- unpinned milestone so derived state can be rebuilt from source.
CREATE TABLE IF NOT EXISTS asg_history_milestone (
commit_id BLOB NOT NULL,
kind TEXT NOT NULL,
timestamp TEXT NOT NULL,
day TEXT NOT NULL,
namespace TEXT NOT NULL,
agent_id TEXT NOT NULL,
description TEXT NOT NULL,
state_root BLOB,
git_sha TEXT,
PRIMARY KEY (commit_id, kind)
);
CREATE INDEX IF NOT EXISTS idx_asg_history_milestone_ts
ON asg_history_milestone(timestamp);
",
)
.map_err(|e| StorageError::Backend(format!("init tables: {}", e)))?;
let milestone_cols: Vec<String> = {
let mut stmt = conn
.prepare("PRAGMA table_info(asg_history_milestone)")
.map_err(|e| StorageError::Backend(format!("pragma milestone: {}", e)))?;
let rows = stmt
.query_map([], |row| row.get::<_, String>(1))
.map_err(|e| StorageError::Backend(format!("pragma query: {}", e)))?;
let mut cols = Vec::new();
for r in rows {
cols.push(r.map_err(|e| StorageError::Backend(format!("pragma row: {}", e)))?);
}
cols
};
if !milestone_cols.iter().any(|c| c == "state_root") {
conn.execute(
"ALTER TABLE asg_history_milestone ADD COLUMN state_root BLOB",
[],
)
.map_err(|e| StorageError::Backend(format!("add milestone state_root: {}", e)))?;
}
if !milestone_cols.iter().any(|c| c == "git_sha") {
conn.execute(
"ALTER TABLE asg_history_milestone ADD COLUMN git_sha TEXT",
[],
)
.map_err(|e| StorageError::Backend(format!("add milestone git_sha: {}", e)))?;
}
let object_cols: Vec<String> = {
let mut stmt = conn
.prepare("PRAGMA table_info(objects)")
.map_err(|e| StorageError::Backend(format!("pragma objects: {}", e)))?;
let rows = stmt
.query_map([], |row| row.get::<_, String>(1))
.map_err(|e| StorageError::Backend(format!("pragma query: {}", e)))?;
let mut cols = Vec::new();
for r in rows {
cols.push(r.map_err(|e| StorageError::Backend(format!("pragma row: {}", e)))?);
}
cols
};
if !object_cols.iter().any(|c| c == "written_at") {
conn.execute(
"ALTER TABLE objects ADD COLUMN written_at INTEGER NOT NULL DEFAULT 0",
[],
)
.map_err(|e| StorageError::Backend(format!("add objects written_at: {}", e)))?;
}
let leaf_ref_cols: Vec<String> = {
let mut stmt = conn
.prepare("PRAGMA table_info(leaf_index_refs)")
.map_err(|e| StorageError::Backend(format!("pragma leaf_index_refs: {}", e)))?;
let rows = stmt
.query_map([], |row| row.get::<_, String>(1))
.map_err(|e| StorageError::Backend(format!("pragma query: {}", e)))?;
let mut cols = Vec::new();
for r in rows {
cols.push(r.map_err(|e| StorageError::Backend(format!("pragma row: {}", e)))?);
}
cols
};
if !leaf_ref_cols.iter().any(|c| c == "root") {
conn.execute("ALTER TABLE leaf_index_refs ADD COLUMN root BLOB", [])
.map_err(|e| StorageError::Backend(format!("add leaf_index_refs root: {}", e)))?;
}
let existing_cols: Vec<String> = {
let mut stmt = conn
.prepare("PRAGMA table_info(commits)")
.map_err(|e| StorageError::Backend(format!("pragma commits: {}", e)))?;
let rows = stmt
.query_map([], |row| row.get::<_, String>(1))
.map_err(|e| StorageError::Backend(format!("pragma query: {}", e)))?;
let mut cols = Vec::new();
for r in rows {
cols.push(r.map_err(|e| StorageError::Backend(format!("pragma row: {}", e)))?);
}
cols
};
if !existing_cols.iter().any(|c| c == "epoch_id") {
conn.execute("ALTER TABLE commits ADD COLUMN epoch_id TEXT", [])
.map_err(|e| StorageError::Backend(format!("add epoch_id col: {}", e)))?;
}
if !existing_cols.iter().any(|c| c == "session_id") {
conn.execute("ALTER TABLE commits ADD COLUMN session_id TEXT", [])
.map_err(|e| StorageError::Backend(format!("add session_id col: {}", e)))?;
}
let epoch_cols: Vec<String> = {
let mut stmt = conn
.prepare("PRAGMA table_info(epochs)")
.map_err(|e| StorageError::Backend(format!("pragma epochs: {}", e)))?;
let rows = stmt
.query_map([], |row| row.get::<_, String>(1))
.map_err(|e| StorageError::Backend(format!("pragma query: {}", e)))?;
let mut cols = Vec::new();
for r in rows {
cols.push(r.map_err(|e| StorageError::Backend(format!("pragma row: {}", e)))?);
}
cols
};
if !epoch_cols.iter().any(|c| c == "sealed_commits") {
conn.execute(
"ALTER TABLE epochs ADD COLUMN sealed_commits TEXT NOT NULL DEFAULT '[]'",
[],
)
.map_err(|e| StorageError::Backend(format!("add sealed_commits: {}", e)))?;
}
for (col, ddl) in [
("seal_hash", "ALTER TABLE epochs ADD COLUMN seal_hash BLOB"),
("namespace", "ALTER TABLE epochs ADD COLUMN namespace TEXT"),
(
"scope",
"ALTER TABLE epochs ADD COLUMN scope TEXT NOT NULL DEFAULT 'all'",
),
] {
if !epoch_cols.iter().any(|c| c == col) {
conn.execute(ddl, [])
.map_err(|e| StorageError::Backend(format!("add epochs.{}: {}", col, e)))?;
}
}
conn.execute(
"CREATE INDEX IF NOT EXISTS idx_epochs_namespace ON epochs(namespace)",
[],
)
.map_err(|e| StorageError::Backend(format!("idx_epochs_namespace: {}", e)))?;
conn.execute(
"CREATE INDEX IF NOT EXISTS idx_commits_epoch ON commits(epoch_id)",
[],
)
.map_err(|e| StorageError::Backend(format!("idx epoch: {}", e)))?;
conn.execute(
"CREATE INDEX IF NOT EXISTS idx_commits_session ON commits(session_id)",
[],
)
.map_err(|e| StorageError::Backend(format!("idx session: {}", e)))?;
let refs_cols: Vec<String> = {
let mut stmt = conn
.prepare("PRAGMA table_info(refs)")
.map_err(|e| StorageError::Backend(format!("pragma refs: {}", e)))?;
let rows = stmt
.query_map([], |row| row.get::<_, String>(1))
.map_err(|e| StorageError::Backend(format!("pragma query: {}", e)))?;
let mut cols = Vec::new();
for r in rows {
cols.push(r.map_err(|e| StorageError::Backend(format!("pragma row: {}", e)))?);
}
cols
};
if !refs_cols.iter().any(|c| c == "namespace") {
conn.execute_batch(
"
CREATE TABLE refs_new (
namespace TEXT NOT NULL,
name TEXT NOT NULL,
target BLOB NOT NULL,
PRIMARY KEY (namespace, name)
);
INSERT INTO refs_new (namespace, name, target)
SELECT 'default', name, target FROM refs;
DROP TABLE refs;
ALTER TABLE refs_new RENAME TO refs;
",
)
.map_err(|e| StorageError::Backend(format!("migrate refs: {}", e)))?;
}
conn.execute(
"INSERT OR IGNORE INTO namespaces (name, created_at) VALUES ('default', ?1)",
params![chrono::Utc::now().to_rfc3339()],
)
.map_err(|e| StorageError::Backend(format!("seed default namespace: {}", e)))?;
let session_cols: Vec<String> = {
let mut stmt = conn
.prepare("PRAGMA table_info(sessions)")
.map_err(|e| StorageError::Backend(format!("pragma sessions: {}", e)))?;
let rows = stmt
.query_map([], |row| row.get::<_, String>(1))
.map_err(|e| StorageError::Backend(format!("pragma query: {}", e)))?;
let mut cols = Vec::new();
for r in rows {
cols.push(r.map_err(|e| StorageError::Backend(format!("pragma row: {}", e)))?);
}
cols
};
if !session_cols.iter().any(|c| c == "scope_namespace") {
conn.execute("ALTER TABLE sessions ADD COLUMN scope_namespace TEXT", [])
.map_err(|e| StorageError::Backend(format!("add scope_namespace: {}", e)))?;
}
Ok(())
}
fn lock_conn(&self) -> Result<ConnGuard<'_>, StorageError> {
let waiting = metrics::gauge!(
"db.client.connection.pending_requests",
POOL_NAME => SQLITE_POOL
);
waiting.increment(1.0);
let started = Instant::now();
let conn = self.conn.lock();
waiting.decrement(1.0);
metrics::histogram!(
"db.client.connection.wait_time",
POOL_NAME => SQLITE_POOL
)
.record(started.elapsed().as_secs_f64());
Ok(ConnGuard {
conn: conn.map_err(|e| StorageError::Backend(e.to_string()))?,
since: Instant::now(),
})
}
}
const POOL_NAME: &str = "db.client.connection.pool.name";
const SQLITE_POOL: &str = "sqlite";
fn describe_connection_metrics() {
metrics::describe_gauge!(
"db.client.connection.pending_requests",
"The number of current pending requests for an open connection."
);
metrics::describe_histogram!(
"db.client.connection.wait_time",
metrics::Unit::Seconds,
"The time it took to obtain an open connection from the pool."
);
metrics::describe_histogram!(
"db.client.connection.use_time",
metrics::Unit::Seconds,
"The time between borrowing a connection and returning it to the pool."
);
}
struct ConnGuard<'a> {
conn: std::sync::MutexGuard<'a, Connection>,
since: Instant,
}
impl std::ops::Deref for ConnGuard<'_> {
type Target = Connection;
fn deref(&self) -> &Connection {
&self.conn
}
}
impl std::ops::DerefMut for ConnGuard<'_> {
fn deref_mut(&mut self) -> &mut Connection {
&mut self.conn
}
}
impl Drop for ConnGuard<'_> {
fn drop(&mut self) {
metrics::histogram!(
"db.client.connection.use_time",
POOL_NAME => SQLITE_POOL
)
.record(self.since.elapsed().as_secs_f64());
}
}
fn totals(conn: &Connection) -> Result<(i64, i64, i64), StorageError> {
let objects: i64 = conn
.query_row("SELECT COUNT(*) FROM objects", [], |row| row.get(0))
.map_err(|e| StorageError::Backend(format!("count objects: {}", e)))?;
let commits: i64 = conn
.query_row("SELECT COUNT(*) FROM commits", [], |row| row.get(0))
.map_err(|e| StorageError::Backend(format!("count commits: {}", e)))?;
let page_count: i64 = conn
.query_row("PRAGMA page_count", [], |row| row.get(0))
.map_err(|e| StorageError::Backend(format!("page_count: {}", e)))?;
let page_size: i64 = conn
.query_row("PRAGMA page_size", [], |row| row.get(0))
.map_err(|e| StorageError::Backend(format!("page_size: {}", e)))?;
Ok((objects, commits, page_count * page_size))
}
impl ObjectStore for SqliteStorage {
fn get_object(&self, id: &ObjectId) -> Result<Option<Object>, StorageError> {
let conn = self.lock_conn()?;
let result: Option<Vec<u8>> = conn
.query_row(
"SELECT data FROM objects WHERE id = ?1",
params![id.as_bytes().as_slice()],
|row| row.get(0),
)
.optional()
.map_err(|e| StorageError::Backend(format!("get object: {}", e)))?;
match result {
Some(data) => {
let obj: Object = serde_json::from_slice(&data)
.map_err(|e| StorageError::Serialization(e.to_string()))?;
Ok(Some(obj))
}
None => Ok(None),
}
}
fn put_object(&self, obj: &Object) -> Result<ObjectId, StorageError> {
let id = obj.id();
let data =
serde_json::to_vec(obj).map_err(|e| StorageError::Serialization(e.to_string()))?;
let conn = self.lock_conn()?;
conn.execute(
PUT_OBJECT,
params![
id.as_bytes().as_slice(),
data,
now_millis(),
freshen_after_millis()
],
)
.map_err(|e| StorageError::Backend(format!("put object: {}", e)))?;
Ok(id)
}
fn leaf_index_is_built(&self, namespace: &str, ref_name: &str) -> Result<bool, StorageError> {
let conn = self.lock_conn()?;
conn.query_row(
"SELECT EXISTS(SELECT 1 FROM leaf_index_refs WHERE namespace = ?1 AND ref = ?2)",
params![namespace, ref_name],
|row| row.get(0),
)
.map_err(|e| StorageError::Backend(format!("leaf_index_is_built: {}", e)))
}
fn leaf_index_build(
&self,
namespace: &str,
ref_name: &str,
entries: &[(String, String)],
) -> Result<(), StorageError> {
let mut conn = self.lock_conn()?;
let tx = conn
.transaction()
.map_err(|e| StorageError::Backend(format!("leaf_index_build tx: {}", e)))?;
leaf_set_replace(&tx, namespace, ref_name, None, entries)?;
tx.commit()
.map_err(|e| StorageError::Backend(format!("leaf_index_build commit: {}", e)))
}
fn leaf_index_apply(
&self,
namespace: &str,
ref_name: &str,
removed_paths: &[String],
added: &[(String, String)],
) -> Result<(), StorageError> {
let mut conn = self.lock_conn()?;
let tx = conn
.transaction()
.map_err(|e| StorageError::Backend(format!("leaf_index_apply tx: {}", e)))?;
let built = tx
.execute(
"UPDATE leaf_index_refs SET root = NULL WHERE namespace = ?1 AND ref = ?2",
params![namespace, ref_name],
)
.map_err(|e| StorageError::Backend(format!("leaf_index_apply check: {}", e)))?
> 0;
if built {
leaf_set_apply(&tx, namespace, ref_name, removed_paths, added)?;
}
tx.commit()
.map_err(|e| StorageError::Backend(format!("leaf_index_apply commit: {}", e)))
}
fn leaf_index_tracks_roots(&self) -> bool {
true
}
fn leaf_index_root(
&self,
namespace: &str,
ref_name: &str,
) -> Result<Option<ObjectId>, StorageError> {
let conn = self.lock_conn()?;
let root: Option<Option<Vec<u8>>> = conn
.query_row(
"SELECT root FROM leaf_index_refs WHERE namespace = ?1 AND ref = ?2",
params![namespace, ref_name],
|row| row.get(0),
)
.optional()
.map_err(|e| StorageError::Backend(format!("leaf_index_root: {}", e)))?;
Ok(root.flatten().as_deref().and_then(object_id_from_bytes))
}
fn leaf_index_build_at(
&self,
namespace: &str,
ref_name: &str,
root: &ObjectId,
entries: &[(String, String)],
) -> Result<(), StorageError> {
let mut conn = self.lock_conn()?;
let tx = conn
.transaction()
.map_err(|e| StorageError::Backend(format!("leaf_index_build tx: {}", e)))?;
leaf_set_replace(&tx, namespace, ref_name, Some(root), entries)?;
tx.commit()
.map_err(|e| StorageError::Backend(format!("leaf_index_build commit: {}", e)))
}
fn leaf_index_advance(
&self,
namespace: &str,
ref_name: &str,
from: &ObjectId,
to: &ObjectId,
removed_paths: &[String],
added: &[(String, String)],
) -> Result<bool, StorageError> {
let mut conn = self.lock_conn()?;
let tx = conn
.transaction()
.map_err(|e| StorageError::Backend(format!("leaf_index_advance tx: {}", e)))?;
let moved = tx
.execute(
"UPDATE leaf_index_refs SET root = ?4 \
WHERE namespace = ?1 AND ref = ?2 AND root = ?3",
params![
namespace,
ref_name,
from.as_bytes().as_slice(),
to.as_bytes().as_slice()
],
)
.map_err(|e| StorageError::Backend(format!("leaf_index_advance root: {}", e)))?
> 0;
if !moved {
return Ok(false);
}
leaf_set_apply(&tx, namespace, ref_name, removed_paths, added)?;
tx.commit()
.map_err(|e| StorageError::Backend(format!("leaf_index_advance commit: {}", e)))?;
Ok(true)
}
fn leaf_index_search(
&self,
namespace: &str,
ref_name: &str,
query_lower: &str,
limit: usize,
) -> Result<Option<Vec<(String, String)>>, StorageError> {
let conn = self.lock_conn()?;
let built: bool = conn
.query_row(
"SELECT EXISTS(SELECT 1 FROM leaf_index_refs WHERE namespace = ?1 AND ref = ?2)",
params![namespace, ref_name],
|row| row.get(0),
)
.map_err(|e| StorageError::Backend(format!("leaf_index_search check: {}", e)))?;
if !built {
return Ok(None); }
let mut out = Vec::new();
if query_lower.chars().count() >= 3 {
let match_expr = format!("\"{}\"", query_lower.replace('"', "\"\""));
let mut stmt = conn
.prepare_cached(
"SELECT r.path, r.value FROM leaf_rows r \
WHERE r.namespace = ?1 AND r.ref = ?2 \
AND r.id IN (SELECT rowid FROM leaf_fts WHERE leaf_fts MATCH ?3) \
LIMIT ?4",
)
.map_err(|e| StorageError::Backend(format!("leaf_index_search prep: {}", e)))?;
let rows = stmt
.query_map(
params![namespace, ref_name, match_expr, limit as i64],
|row| Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?)),
)
.map_err(|e| StorageError::Backend(format!("leaf_index_search query: {}", e)))?;
for r in rows {
out.push(
r.map_err(|e| StorageError::Backend(format!("leaf_index_search row: {}", e)))?,
);
}
} else {
let mut pattern = String::from("%");
for ch in query_lower.chars() {
if matches!(ch, '%' | '_' | '\\') {
pattern.push('\\');
}
pattern.push(ch);
}
pattern.push('%');
let mut stmt = conn
.prepare_cached(
"SELECT path, value FROM leaf_rows \
WHERE namespace = ?1 AND ref = ?2 AND value LIKE ?3 ESCAPE '\\' LIMIT ?4",
)
.map_err(|e| StorageError::Backend(format!("leaf_index_search prep2: {}", e)))?;
let rows = stmt
.query_map(params![namespace, ref_name, pattern, limit as i64], |row| {
Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?))
})
.map_err(|e| StorageError::Backend(format!("leaf_index_search query2: {}", e)))?;
for r in rows {
out.push(r.map_err(|e| {
StorageError::Backend(format!("leaf_index_search row2: {}", e))
})?);
}
}
Ok(Some(out))
}
fn has_object(&self, id: &ObjectId) -> Result<bool, StorageError> {
let conn = self.lock_conn()?;
let exists: bool = conn
.query_row(
"SELECT EXISTS(SELECT 1 FROM objects WHERE id = ?1)",
params![id.as_bytes().as_slice()],
|row| row.get(0),
)
.map_err(|e| StorageError::Backend(format!("has object: {}", e)))?;
Ok(exists)
}
fn batch_put_objects(&self, objs: &[Object]) -> Result<Vec<ObjectId>, StorageError> {
let conn = self.lock_conn()?;
let tx = conn
.unchecked_transaction()
.map_err(|e| StorageError::Backend(format!("begin tx: {}", e)))?;
let mut ids = Vec::with_capacity(objs.len());
{
let mut stmt = tx
.prepare_cached(PUT_OBJECT)
.map_err(|e| StorageError::Backend(format!("prepare: {}", e)))?;
let now = now_millis();
for obj in objs {
let id = obj.id();
let data = serde_json::to_vec(obj)
.map_err(|e| StorageError::Serialization(e.to_string()))?;
stmt.execute(params![
id.as_bytes().as_slice(),
data,
now,
freshen_after_millis()
])
.map_err(|e| StorageError::Backend(format!("batch put: {}", e)))?;
ids.push(id);
}
}
tx.commit()
.map_err(|e| StorageError::Backend(format!("commit tx: {}", e)))?;
Ok(ids)
}
}
fn leaf_set_replace(
tx: &rusqlite::Transaction<'_>,
namespace: &str,
ref_name: &str,
root: Option<&ObjectId>,
entries: &[(String, String)],
) -> Result<(), StorageError> {
tx.execute(
"INSERT INTO leaf_index_refs (namespace, ref, root) VALUES (?1, ?2, ?3) \
ON CONFLICT(namespace, ref) DO UPDATE SET root = excluded.root",
params![namespace, ref_name, root.map(|r| r.as_bytes().to_vec())],
)
.map_err(|e| StorageError::Backend(format!("leaf_index_build mark: {}", e)))?;
tx.execute(
"DELETE FROM leaf_rows WHERE namespace = ?1 AND ref = ?2",
params![namespace, ref_name],
)
.map_err(|e| StorageError::Backend(format!("leaf_index_build clear: {}", e)))?;
let mut stmt = tx
.prepare_cached(
"INSERT INTO leaf_rows (namespace, ref, path, value) VALUES (?1, ?2, ?3, ?4)",
)
.map_err(|e| StorageError::Backend(format!("leaf_index_build prep: {}", e)))?;
for (path, value) in entries {
stmt.execute(params![namespace, ref_name, path, value])
.map_err(|e| StorageError::Backend(format!("leaf_index_build row: {}", e)))?;
}
Ok(())
}
fn leaf_set_apply(
tx: &rusqlite::Transaction<'_>,
namespace: &str,
ref_name: &str,
removed_paths: &[String],
added: &[(String, String)],
) -> Result<(), StorageError> {
let mut del = tx
.prepare_cached("DELETE FROM leaf_rows WHERE namespace = ?1 AND ref = ?2 AND path = ?3")
.map_err(|e| StorageError::Backend(format!("leaf_index_apply del prep: {}", e)))?;
for path in removed_paths {
del.execute(params![namespace, ref_name, path])
.map_err(|e| StorageError::Backend(format!("leaf_index_apply del: {}", e)))?;
}
let mut ins = tx
.prepare_cached(
"INSERT INTO leaf_rows (namespace, ref, path, value) VALUES (?1, ?2, ?3, ?4)",
)
.map_err(|e| StorageError::Backend(format!("leaf_index_apply ins prep: {}", e)))?;
for (path, value) in added {
ins.execute(params![namespace, ref_name, path, value])
.map_err(|e| StorageError::Backend(format!("leaf_index_apply ins: {}", e)))?;
}
Ok(())
}
impl CommitStore for SqliteStorage {
fn put_commit_traced(
&self,
commit: &Commit,
trace: Option<&CommitTrace>,
) -> Result<(), StorageError> {
let Some(trace) = trace else {
return self.put_commit(commit);
};
let data =
serde_json::to_vec(commit).map_err(|e| StorageError::Serialization(e.to_string()))?;
let timestamp = commit.timestamp.to_rfc3339();
let mut conn = self.lock_conn()?;
let tx = conn
.transaction()
.map_err(|e| StorageError::Backend(format!("begin put commit: {}", e)))?;
tx.execute(
"INSERT OR IGNORE INTO commits (id, data, timestamp) VALUES (?1, ?2, ?3)",
params![commit.id.as_bytes().as_slice(), data, timestamp],
)
.map_err(|e| StorageError::Backend(format!("put commit: {}", e)))?;
tx.execute(
"INSERT OR IGNORE INTO commit_traces (commit_id, trace_id, span_id)
VALUES (?1, ?2, ?3)",
params![
commit.id.as_bytes().as_slice(),
trace.trace_id,
trace.span_id
],
)
.map_err(|e| StorageError::Backend(format!("set commit trace: {}", e)))?;
tx.commit()
.map_err(|e| StorageError::Backend(format!("commit put commit: {}", e)))
}
fn set_commit_trace(
&self,
commit_id: &ObjectId,
trace: &CommitTrace,
) -> Result<(), StorageError> {
let conn = self.lock_conn()?;
conn.execute(
"INSERT OR IGNORE INTO commit_traces (commit_id, trace_id, span_id)
VALUES (?1, ?2, ?3)",
params![
commit_id.as_bytes().as_slice(),
trace.trace_id,
trace.span_id
],
)
.map_err(|e| StorageError::Backend(format!("set commit trace: {}", e)))?;
Ok(())
}
fn get_commit_trace(&self, commit_id: &ObjectId) -> Result<Option<CommitTrace>, StorageError> {
let conn = self.lock_conn()?;
conn.query_row(
"SELECT trace_id, span_id FROM commit_traces WHERE commit_id = ?1",
params![commit_id.as_bytes().as_slice()],
|row| {
Ok(CommitTrace {
trace_id: row.get(0)?,
span_id: row.get(1)?,
})
},
)
.optional()
.map_err(|e| StorageError::Backend(format!("get commit trace: {}", e)))
}
fn all_commit_ids(&self) -> Result<Vec<ObjectId>, StorageError> {
let conn = self.lock_conn()?;
let mut stmt = conn
.prepare("SELECT id FROM commits")
.map_err(|e| StorageError::Backend(format!("all commit ids: {}", e)))?;
let rows = stmt
.query_map([], |row| row.get::<_, Vec<u8>>(0))
.map_err(|e| StorageError::Backend(format!("all commit ids: {}", e)))?;
let mut ids = Vec::new();
for row in rows {
let bytes = row.map_err(|e| StorageError::Backend(format!("all commit ids: {}", e)))?;
if bytes.len() == 32 {
let mut arr = [0u8; 32];
arr.copy_from_slice(&bytes);
ids.push(ObjectId::from_bytes(arr));
}
}
Ok(ids)
}
fn history_extract_batch(&self, batch_size: usize) -> Result<usize, StorageError> {
let batch_size = batch_size.max(1) as i64;
let conn = self.lock_conn()?;
let tx = conn
.unchecked_transaction()
.map_err(|e| StorageError::Backend(format!("history tx: {}", e)))?;
let cursor: i64 = tx
.query_row(
"SELECT value FROM asg_history_meta WHERE key = 'commit_cursor'",
[],
|row| row.get::<_, String>(0),
)
.optional()
.map_err(|e| StorageError::Backend(format!("history cursor read: {}", e)))?
.and_then(|s| s.parse::<i64>().ok())
.unwrap_or(0);
let batch: Vec<(i64, Vec<u8>, String)> = {
let mut stmt = tx
.prepare(
"SELECT c.rowid, c.data, COALESCE(s.scope_namespace, ?3) \
FROM commits c \
LEFT JOIN sessions s ON c.session_id = s.id \
WHERE c.rowid > ?1 ORDER BY c.rowid LIMIT ?2",
)
.map_err(|e| StorageError::Backend(format!("history select: {}", e)))?;
let rows = stmt
.query_map(
params![cursor, batch_size, HISTORY_NAMESPACE_UNKNOWN],
|row| {
Ok((
row.get::<_, i64>(0)?,
row.get::<_, Vec<u8>>(1)?,
row.get::<_, String>(2)?,
))
},
)
.map_err(|e| StorageError::Backend(format!("history query: {}", e)))?;
let mut out = Vec::new();
for r in rows {
out.push(r.map_err(|e| StorageError::Backend(format!("history row: {}", e)))?);
}
out
};
if batch.is_empty() {
return Ok(0);
}
let mut max_rowid = cursor;
let mut processed = 0usize;
for (rowid, data, namespace) in &batch {
max_rowid = (*rowid).max(max_rowid);
let commit: Commit = serde_json::from_slice(data)
.map_err(|e| StorageError::Serialization(e.to_string()))?;
let day = commit.timestamp.format("%Y-%m-%d").to_string();
let ts = commit.timestamp.to_rfc3339();
let agent = &commit.agent_id;
let category = format!("{:?}", commit.intent.category);
tx.execute(
"INSERT INTO asg_history_commit_rollup \
(day, namespace, agent_id, intent_category, commit_count, first_ts, last_ts) \
VALUES (?1, ?2, ?3, ?4, 1, ?5, ?5) \
ON CONFLICT(day, namespace, agent_id, intent_category) DO UPDATE SET \
commit_count = commit_count + 1, \
first_ts = MIN(first_ts, excluded.first_ts), \
last_ts = MAX(last_ts, excluded.last_ts)",
params![day, namespace, agent, category, ts],
)
.map_err(|e| StorageError::Backend(format!("history rollup upsert: {}", e)))?;
if commit.intent.category == IntentCategory::Checkpoint {
let pinned_root = commit
.intent
.tags
.iter()
.any(|t| t == TAG_PIN_STATE)
.then(|| commit.state_root.as_bytes().to_vec());
let git_sha = commit
.intent
.tags
.iter()
.find_map(|t| t.strip_prefix(TAG_GIT_REVISION))
.filter(|sha| !sha.is_empty());
tx.execute(
"INSERT OR IGNORE INTO asg_history_milestone \
(commit_id, kind, timestamp, day, namespace, agent_id, description, state_root, git_sha) \
VALUES (?1, 'checkpoint', ?2, ?3, ?4, ?5, ?6, ?7, ?8)",
params![
commit.id.as_bytes().as_slice(),
ts,
day,
namespace,
agent,
commit.intent.description,
pinned_root,
git_sha,
],
)
.map_err(|e| StorageError::Backend(format!("history milestone: {}", e)))?;
}
processed += 1;
}
tx.execute(
"INSERT INTO asg_history_meta (key, value) VALUES ('commit_cursor', ?1) \
ON CONFLICT(key) DO UPDATE SET value = excluded.value",
params![max_rowid.to_string()],
)
.map_err(|e| StorageError::Backend(format!("history cursor write: {}", e)))?;
tx.commit()
.map_err(|e| StorageError::Backend(format!("history commit: {}", e)))?;
Ok(processed)
}
fn history_cursor(&self) -> Result<i64, StorageError> {
let conn = self.lock_conn()?;
let cursor: i64 = conn
.query_row(
"SELECT value FROM asg_history_meta WHERE key = 'commit_cursor'",
[],
|row| row.get::<_, String>(0),
)
.optional()
.map_err(|e| StorageError::Backend(format!("history cursor: {}", e)))?
.and_then(|s| s.parse::<i64>().ok())
.unwrap_or(0);
Ok(cursor)
}
fn history_undistilled_commit_count(&self) -> Result<i64, StorageError> {
let conn = self.lock_conn()?;
let cursor: i64 = conn
.query_row(
"SELECT value FROM asg_history_meta WHERE key = 'commit_cursor'",
[],
|row| row.get::<_, String>(0),
)
.optional()
.map_err(|e| StorageError::Backend(format!("undistilled cursor: {}", e)))?
.and_then(|s| s.parse::<i64>().ok())
.unwrap_or(0);
let n: i64 = conn
.query_row(
"SELECT COUNT(*) FROM commits WHERE rowid > ?1",
params![cursor],
|row| row.get(0),
)
.map_err(|e| StorageError::Backend(format!("undistilled count: {}", e)))?;
Ok(n)
}
fn history_rollup(&self) -> Result<Vec<HistoryRollupRow>, StorageError> {
let conn = self.lock_conn()?;
let mut stmt = conn
.prepare(
"SELECT day, namespace, agent_id, intent_category, commit_count, first_ts, last_ts \
FROM asg_history_commit_rollup \
ORDER BY day, namespace, agent_id, intent_category",
)
.map_err(|e| StorageError::Backend(format!("history rollup read: {}", e)))?;
let rows = stmt
.query_map([], |row| {
Ok(HistoryRollupRow {
day: row.get(0)?,
namespace: row.get(1)?,
agent_id: row.get(2)?,
intent_category: row.get(3)?,
commit_count: row.get(4)?,
first_ts: row.get(5)?,
last_ts: row.get(6)?,
})
})
.map_err(|e| StorageError::Backend(format!("history rollup query: {}", e)))?;
let mut out = Vec::new();
for r in rows {
out.push(r.map_err(|e| StorageError::Backend(format!("history rollup row: {}", e)))?);
}
Ok(out)
}
fn history_milestones(&self, limit: usize) -> Result<Vec<HistoryMilestoneRow>, StorageError> {
let conn = self.lock_conn()?;
let mut stmt = conn
.prepare(
"SELECT commit_id, kind, timestamp, day, namespace, agent_id, description, state_root, git_sha \
FROM asg_history_milestone ORDER BY timestamp DESC LIMIT ?1",
)
.map_err(|e| StorageError::Backend(format!("history milestones read: {}", e)))?;
let rows = stmt
.query_map(params![limit as i64], |row| {
Ok((
row.get::<_, Vec<u8>>(0)?,
row.get::<_, String>(1)?,
row.get::<_, String>(2)?,
row.get::<_, String>(3)?,
row.get::<_, String>(4)?,
row.get::<_, String>(5)?,
row.get::<_, String>(6)?,
row.get::<_, Option<Vec<u8>>>(7)?,
row.get::<_, Option<String>>(8)?,
))
})
.map_err(|e| StorageError::Backend(format!("history milestones query: {}", e)))?;
let mut out = Vec::new();
for r in rows {
let (
id_bytes,
kind,
timestamp,
day,
namespace,
agent_id,
description,
root_bytes,
git_sha,
) = r.map_err(|e| StorageError::Backend(format!("history milestone row: {}", e)))?;
let Some(commit_id) = object_id_from_bytes(&id_bytes) else {
continue;
};
out.push(HistoryMilestoneRow {
commit_id,
kind,
timestamp,
day,
namespace,
agent_id,
description,
state_root: root_bytes.as_deref().and_then(object_id_from_bytes),
git_sha,
});
}
Ok(out)
}
fn history_is_commit_distilled(&self, id: &ObjectId) -> Result<bool, StorageError> {
let conn = self.lock_conn()?;
let cursor: i64 = conn
.query_row(
"SELECT value FROM asg_history_meta WHERE key = 'commit_cursor'",
[],
|row| row.get::<_, String>(0),
)
.optional()
.map_err(|e| StorageError::Backend(format!("distilled cursor: {}", e)))?
.and_then(|s| s.parse::<i64>().ok())
.unwrap_or(0);
let rowid: Option<i64> = conn
.query_row(
"SELECT rowid FROM commits WHERE id = ?1",
params![id.as_bytes().as_slice()],
|row| row.get(0),
)
.optional()
.map_err(|e| StorageError::Backend(format!("distilled rowid: {}", e)))?;
Ok(matches!(rowid, Some(r) if r <= cursor))
}
fn history_retained_state_roots(&self) -> Result<Vec<ObjectId>, StorageError> {
let conn = self.lock_conn()?;
let mut stmt = conn
.prepare(
"SELECT DISTINCT state_root FROM asg_history_milestone WHERE state_root IS NOT NULL",
)
.map_err(|e| StorageError::Backend(format!("retained roots read: {}", e)))?;
let rows = stmt
.query_map([], |row| row.get::<_, Vec<u8>>(0))
.map_err(|e| StorageError::Backend(format!("retained roots query: {}", e)))?;
let mut out = Vec::new();
for r in rows {
let bytes = r.map_err(|e| StorageError::Backend(format!("retained root: {}", e)))?;
if let Some(id) = object_id_from_bytes(&bytes) {
out.push(id);
}
}
Ok(out)
}
fn history_gc_reachability(
&self,
roots: &[ObjectId],
batch: usize,
) -> Result<GcReachability, StorageError> {
let batch = batch.max(1) as i64;
let conn = self.lock_conn()?;
gc_build_mark(&conn, roots, batch)?;
let live: i64 = conn
.query_row("SELECT COUNT(*) FROM gc_mark", [], |row| row.get(0))
.map_err(|e| StorageError::Backend(format!("gc live count: {}", e)))?;
let total: i64 = conn
.query_row("SELECT COUNT(*) FROM objects", [], |row| row.get(0))
.map_err(|e| StorageError::Backend(format!("gc total count: {}", e)))?;
conn.execute("DELETE FROM gc_mark", [])
.map_err(|e| StorageError::Backend(format!("gc cleanup: {}", e)))?;
Ok(GcReachability {
total_objects: total,
live_objects: live,
reclaimable_objects: (total - live).max(0),
roots_walked: roots.len(),
})
}
fn history_gc_sweep(&self, roots: &[ObjectId], batch: usize) -> Result<GcSweep, StorageError> {
let batch = batch.max(1) as i64;
{
let gc = self
.gc_conn
.lock()
.map_err(|e| StorageError::Backend(e.to_string()))?;
if let Some(gc_conn) = gc.as_ref() {
return gc_sweep_locked(gc_conn, roots, batch, self.gc_grace);
}
}
let conn = self.lock_conn()?;
let own_lock = conn.is_autocommit();
if own_lock {
conn.execute_batch("BEGIN IMMEDIATE")
.map_err(|e| StorageError::Backend(format!("gc sweep lock: {}", e)))?;
}
let result = gc_sweep_locked(&conn, roots, batch, self.gc_grace);
if own_lock {
match &result {
Ok(_) => conn
.execute_batch("COMMIT")
.map_err(|e| StorageError::Backend(format!("gc sweep commit: {}", e)))?,
Err(_) => {
let _ = conn.execute_batch("ROLLBACK");
}
}
}
result
}
fn gc_pin_root(&self, key: &str, root: &ObjectId) -> Result<(), StorageError> {
let conn = self.lock_conn()?;
conn.execute(
"INSERT OR REPLACE INTO gc_pending_roots (key, root, updated_at) VALUES (?1, ?2, ?3)",
params![
key,
root.as_bytes().as_slice(),
chrono::Utc::now().timestamp()
],
)
.map_err(|e| StorageError::Backend(format!("gc pin root: {}", e)))?;
Ok(())
}
fn gc_unpin_root(&self, key: &str) -> Result<(), StorageError> {
let conn = self.lock_conn()?;
conn.execute("DELETE FROM gc_pending_roots WHERE key = ?1", params![key])
.map_err(|e| StorageError::Backend(format!("gc unpin root: {}", e)))?;
Ok(())
}
fn gc_pinned_roots(&self, max_age: std::time::Duration) -> Result<Vec<ObjectId>, StorageError> {
let conn = self.lock_conn()?;
gc_pending_roots(&conn, max_age)
}
fn history_gc_lock_writers(&self) -> Result<(), StorageError> {
let Some(path) = self.path.as_ref() else {
let conn = self.lock_conn()?;
return conn
.execute_batch("BEGIN IMMEDIATE")
.map_err(|e| StorageError::Backend(format!("gc lock writers: {}", e)));
};
let mut gc = self
.gc_conn
.lock()
.map_err(|e| StorageError::Backend(e.to_string()))?;
if gc.is_some() {
return Err(StorageError::Backend(
"gc lock writers: a sweep already holds the lock".into(),
));
}
let conn = Connection::open(path)
.map_err(|e| StorageError::Backend(format!("gc lock connection: {}", e)))?;
oxtel_sql::rusqlite::instrument(&conn);
let _ = conn.busy_timeout(std::time::Duration::from_secs(30));
conn.execute_batch("BEGIN IMMEDIATE")
.map_err(|e| StorageError::Backend(format!("gc lock writers: {}", e)))?;
*gc = Some(conn);
Ok(())
}
fn history_gc_unlock_writers(&self, commit: bool) -> Result<(), StorageError> {
let held = self
.gc_conn
.lock()
.map_err(|e| StorageError::Backend(e.to_string()))?
.take();
if let Some(conn) = held {
if commit {
conn.execute_batch("COMMIT").map_err(|e| {
StorageError::Backend(format!("gc unlock writers (COMMIT): {}", e))
})?;
}
return Ok(());
}
let conn = self.lock_conn()?;
if conn.is_autocommit() {
return Ok(());
}
let end = if commit { "COMMIT" } else { "ROLLBACK" };
conn.execute_batch(end)
.map_err(|e| StorageError::Backend(format!("gc unlock writers ({end}): {}", e)))
}
fn history_unpin_legacy_milestones(&self) -> Result<usize, StorageError> {
let conn = self.lock_conn()?;
let unrequested: Vec<Vec<u8>> = {
let mut stmt = conn
.prepare(
"SELECT m.commit_id, c.data FROM asg_history_milestone m \
JOIN commits c ON c.id = m.commit_id \
WHERE m.state_root IS NOT NULL",
)
.map_err(|e| StorageError::Backend(format!("unpin read: {}", e)))?;
let rows = stmt
.query_map([], |row| {
Ok((row.get::<_, Vec<u8>>(0)?, row.get::<_, Vec<u8>>(1)?))
})
.map_err(|e| StorageError::Backend(format!("unpin query: {}", e)))?;
let mut out = Vec::new();
for r in rows {
let (id, data) =
r.map_err(|e| StorageError::Backend(format!("unpin row: {}", e)))?;
let commit: Commit = serde_json::from_slice(&data)
.map_err(|e| StorageError::Serialization(e.to_string()))?;
if !commit.intent.tags.iter().any(|t| t == TAG_PIN_STATE) {
out.push(id);
}
}
out
};
gc_in_tx(&conn, "unpin milestones", |c| {
let mut updated = 0usize;
for id in &unrequested {
updated += c
.execute(
"UPDATE asg_history_milestone SET state_root = NULL WHERE commit_id = ?1",
params![id.as_slice()],
)
.map_err(|e| StorageError::Backend(format!("unpin update: {}", e)))?;
}
Ok(updated)
})
}
fn history_vacuum(&self) -> Result<VacuumStats, StorageError> {
let conn = self.lock_conn()?;
let db_bytes = |conn: &Connection| -> Result<i64, StorageError> {
let pc: i64 = conn
.query_row("PRAGMA page_count", [], |r| r.get(0))
.map_err(|e| StorageError::Backend(format!("page_count: {}", e)))?;
let ps: i64 = conn
.query_row("PRAGMA page_size", [], |r| r.get(0))
.map_err(|e| StorageError::Backend(format!("page_size: {}", e)))?;
Ok(pc * ps)
};
let bytes_before = db_bytes(&conn)?;
conn.execute_batch("VACUUM")
.map_err(|e| StorageError::Backend(format!("vacuum: {}", e)))?;
let bytes_after = db_bytes(&conn)?;
Ok(VacuumStats {
bytes_before,
bytes_after,
bytes_reclaimed: (bytes_before - bytes_after).max(0),
})
}
fn commit_state_roots_recent_first(&self) -> Result<Vec<ObjectId>, StorageError> {
let conn = self.lock_conn()?;
let mut stmt = conn
.prepare("SELECT data FROM commits ORDER BY rowid DESC")
.map_err(|e| StorageError::Backend(format!("commit roots read: {}", e)))?;
let rows = stmt
.query_map([], |row| row.get::<_, Vec<u8>>(0))
.map_err(|e| StorageError::Backend(format!("commit roots query: {}", e)))?;
let mut out = Vec::new();
for r in rows {
let data = r.map_err(|e| StorageError::Backend(format!("commit roots row: {}", e)))?;
let commit: Commit = serde_json::from_slice(&data)
.map_err(|e| StorageError::Serialization(e.to_string()))?;
out.push(commit.state_root);
}
Ok(out)
}
fn store_totals(&self) -> Result<Option<StoreTotals>, StorageError> {
let conn = self.lock_conn()?;
let (objects, commits, bytes) = totals(&conn)?;
Ok(Some(StoreTotals {
objects,
commits,
bytes: self.path.is_some().then_some(bytes),
}))
}
fn history_store_shape(&self) -> Result<StoreShape, StorageError> {
let conn = self.lock_conn()?;
let (objects, commits, total_bytes) = totals(&conn)?;
let (tables, dbstat_available) = match conn.prepare(
"SELECT name, SUM(pgsize) AS bytes FROM dbstat GROUP BY name ORDER BY bytes DESC",
) {
Ok(mut stmt) => {
let rows = stmt.query_map([], |row| {
Ok(TableBytes {
name: row.get::<_, String>(0)?,
bytes: row.get::<_, i64>(1)?,
})
});
match rows {
Ok(iter) => {
let mut v = Vec::new();
let mut ok = true;
for r in iter {
match r {
Ok(tb) => v.push(tb),
Err(_) => {
ok = false;
break;
}
}
}
if ok { (v, true) } else { (Vec::new(), false) }
}
Err(_) => (Vec::new(), false),
}
}
Err(_) => (Vec::new(), false),
};
Ok(StoreShape {
objects,
commits,
total_bytes,
tables,
dbstat_available,
})
}
fn get_commit(&self, id: &ObjectId) -> Result<Option<Commit>, StorageError> {
let conn = self.lock_conn()?;
let result: Option<Vec<u8>> = conn
.query_row(
"SELECT data FROM commits WHERE id = ?1",
params![id.as_bytes().as_slice()],
|row| row.get(0),
)
.optional()
.map_err(|e| StorageError::Backend(format!("get commit: {}", e)))?;
match result {
Some(data) => {
let commit: Commit = serde_json::from_slice(&data)
.map_err(|e| StorageError::Serialization(e.to_string()))?;
Ok(Some(commit))
}
None => Ok(None),
}
}
fn put_commit(&self, commit: &Commit) -> Result<(), StorageError> {
let data =
serde_json::to_vec(commit).map_err(|e| StorageError::Serialization(e.to_string()))?;
let timestamp = commit.timestamp.to_rfc3339();
let conn = self.lock_conn()?;
conn.execute(
"INSERT OR IGNORE INTO commits (id, data, timestamp) VALUES (?1, ?2, ?3)",
params![commit.id.as_bytes().as_slice(), data, timestamp],
)
.map_err(|e| StorageError::Backend(format!("put commit: {}", e)))?;
Ok(())
}
fn has_commit(&self, id: &ObjectId) -> Result<bool, StorageError> {
let conn = self.lock_conn()?;
let exists: bool = conn
.query_row(
"SELECT EXISTS(SELECT 1 FROM commits WHERE id = ?1)",
params![id.as_bytes().as_slice()],
|row| row.get(0),
)
.map_err(|e| StorageError::Backend(format!("has commit: {}", e)))?;
Ok(exists)
}
fn list_commits(&self, from: &ObjectId, limit: usize) -> Result<Vec<Commit>, StorageError> {
let conn = self.lock_conn()?;
let mut result = Vec::new();
let mut current = Some(*from);
while let Some(id) = current {
if result.len() >= limit {
break;
}
let data: Option<Vec<u8>> = conn
.query_row(
"SELECT data FROM commits WHERE id = ?1",
params![id.as_bytes().as_slice()],
|row| row.get(0),
)
.optional()
.map_err(|e| StorageError::Backend(format!("list commits: {}", e)))?;
match data {
Some(data) => {
let commit: Commit = serde_json::from_slice(&data)
.map_err(|e| StorageError::Serialization(e.to_string()))?;
current = commit.parents.first().copied();
result.push(commit);
}
None => break,
}
}
Ok(result)
}
}
impl RefStore for SqliteStorage {
fn create_namespace(&self, namespace: &Namespace) -> Result<(), StorageError> {
let conn = self.lock_conn()?;
let rows = conn
.execute(
"INSERT OR IGNORE INTO namespaces (name, created_at) VALUES (?1, ?2)",
params![namespace.as_str(), chrono::Utc::now().to_rfc3339()],
)
.map_err(|e| StorageError::Backend(format!("create namespace: {}", e)))?;
if rows == 0 {
return Err(StorageError::NamespaceAlreadyExists(
namespace.as_str().to_string(),
));
}
Ok(())
}
fn list_namespaces(&self) -> Result<Vec<Namespace>, StorageError> {
let conn = self.lock_conn()?;
let mut stmt = conn
.prepare("SELECT name FROM namespaces ORDER BY name")
.map_err(|e| StorageError::Backend(format!("list namespaces: {}", e)))?;
let rows = stmt
.query_map([], |row| row.get::<_, String>(0))
.map_err(|e| StorageError::Backend(format!("list namespaces query: {}", e)))?;
let mut result = Vec::new();
for row in rows {
let name =
row.map_err(|e| StorageError::Backend(format!("list namespaces row: {}", e)))?;
let ns = Namespace::new(name)
.map_err(|e| StorageError::Backend(format!("invalid namespace in db: {}", e)))?;
result.push(ns);
}
Ok(result)
}
fn get_ref(&self, namespace: &Namespace, name: &str) -> Result<Option<ObjectId>, StorageError> {
let conn = self.lock_conn()?;
let ns_exists: bool = conn
.query_row(
"SELECT EXISTS(SELECT 1 FROM namespaces WHERE name = ?1)",
params![namespace.as_str()],
|row| row.get(0),
)
.map_err(|e| StorageError::Backend(format!("check namespace: {}", e)))?;
if !ns_exists {
return Err(StorageError::NamespaceNotFound(
namespace.as_str().to_string(),
));
}
let result: Option<Vec<u8>> = conn
.query_row(
"SELECT target FROM refs WHERE namespace = ?1 AND name = ?2",
params![namespace.as_str(), name],
|row| row.get(0),
)
.optional()
.map_err(|e| StorageError::Backend(format!("get ref: {}", e)))?;
match result {
Some(bytes) => {
let mut arr = [0u8; 32];
arr.copy_from_slice(&bytes);
Ok(Some(ObjectId::from_bytes(arr)))
}
None => Ok(None),
}
}
fn set_ref(
&self,
namespace: &Namespace,
name: &str,
target: ObjectId,
) -> Result<(), StorageError> {
let conn = self.lock_conn()?;
let ns_exists: bool = conn
.query_row(
"SELECT EXISTS(SELECT 1 FROM namespaces WHERE name = ?1)",
params![namespace.as_str()],
|row| row.get(0),
)
.map_err(|e| StorageError::Backend(format!("check namespace: {}", e)))?;
if !ns_exists {
return Err(StorageError::NamespaceNotFound(
namespace.as_str().to_string(),
));
}
conn.execute(
"INSERT OR REPLACE INTO refs (namespace, name, target) VALUES (?1, ?2, ?3)",
params![namespace.as_str(), name, target.as_bytes().as_slice()],
)
.map_err(|e| StorageError::Backend(format!("set ref: {}", e)))?;
Ok(())
}
fn cas_ref(
&self,
namespace: &Namespace,
name: &str,
expected: ObjectId,
new: ObjectId,
) -> Result<bool, StorageError> {
let conn = self.lock_conn()?;
let ns_exists: bool = conn
.query_row(
"SELECT EXISTS(SELECT 1 FROM namespaces WHERE name = ?1)",
params![namespace.as_str()],
|row| row.get(0),
)
.map_err(|e| StorageError::Backend(format!("check namespace: {}", e)))?;
if !ns_exists {
return Err(StorageError::NamespaceNotFound(
namespace.as_str().to_string(),
));
}
let rows = conn
.execute(
"UPDATE refs SET target = ?1 \
WHERE namespace = ?2 AND name = ?3 AND target = ?4",
params![
new.as_bytes().as_slice(),
namespace.as_str(),
name,
expected.as_bytes().as_slice()
],
)
.map_err(|e| StorageError::Backend(format!("cas ref: {}", e)))?;
Ok(rows > 0)
}
fn create_ref(
&self,
namespace: &Namespace,
name: &str,
target: ObjectId,
) -> Result<bool, StorageError> {
let conn = self.lock_conn()?;
require_namespace(&conn, namespace)?;
let rows = conn
.execute(
"INSERT OR IGNORE INTO refs (namespace, name, target) VALUES (?1, ?2, ?3)",
params![namespace.as_str(), name, target.as_bytes().as_slice()],
)
.map_err(|e| StorageError::Backend(format!("create ref: {}", e)))?;
Ok(rows > 0)
}
fn cas_delete_ref(
&self,
namespace: &Namespace,
name: &str,
expected: ObjectId,
) -> Result<bool, StorageError> {
let conn = self.lock_conn()?;
require_namespace(&conn, namespace)?;
let rows = conn
.execute(
"DELETE FROM refs WHERE namespace = ?1 AND name = ?2 AND target = ?3",
params![namespace.as_str(), name, expected.as_bytes().as_slice()],
)
.map_err(|e| StorageError::Backend(format!("cas delete ref: {}", e)))?;
Ok(rows > 0)
}
fn list_refs(
&self,
namespace: &Namespace,
prefix: &str,
) -> Result<Vec<(String, ObjectId)>, StorageError> {
let conn = self.lock_conn()?;
let ns_exists: bool = conn
.query_row(
"SELECT EXISTS(SELECT 1 FROM namespaces WHERE name = ?1)",
params![namespace.as_str()],
|row| row.get(0),
)
.map_err(|e| StorageError::Backend(format!("check namespace: {}", e)))?;
if !ns_exists {
return Err(StorageError::NamespaceNotFound(
namespace.as_str().to_string(),
));
}
let mut stmt = conn
.prepare(
"SELECT name, target FROM refs \
WHERE namespace = ?1 AND name LIKE ?2 ORDER BY name",
)
.map_err(|e| StorageError::Backend(format!("list refs: {}", e)))?;
let pattern = format!("{}%", prefix);
let rows = stmt
.query_map(params![namespace.as_str(), pattern], |row| {
let name: String = row.get(0)?;
let bytes: Vec<u8> = row.get(1)?;
Ok((name, bytes))
})
.map_err(|e| StorageError::Backend(format!("list refs query: {}", e)))?;
let mut result = Vec::new();
for row in rows {
let (name, bytes) =
row.map_err(|e| StorageError::Backend(format!("list refs row: {}", e)))?;
let mut arr = [0u8; 32];
arr.copy_from_slice(&bytes);
result.push((name, ObjectId::from_bytes(arr)));
}
Ok(result)
}
fn delete_ref(&self, namespace: &Namespace, name: &str) -> Result<bool, StorageError> {
let conn = self.lock_conn()?;
let ns_exists: bool = conn
.query_row(
"SELECT EXISTS(SELECT 1 FROM namespaces WHERE name = ?1)",
params![namespace.as_str()],
|row| row.get(0),
)
.map_err(|e| StorageError::Backend(format!("check namespace: {}", e)))?;
if !ns_exists {
return Err(StorageError::NamespaceNotFound(
namespace.as_str().to_string(),
));
}
let rows = conn
.execute(
"DELETE FROM refs WHERE namespace = ?1 AND name = ?2",
params![namespace.as_str(), name],
)
.map_err(|e| StorageError::Backend(format!("delete ref: {}", e)))?;
Ok(rows > 0)
}
fn delete_namespace(&self, namespace: &Namespace) -> Result<bool, StorageError> {
if namespace.as_str() == Namespace::DEFAULT {
return Err(StorageError::InvalidOperation(
"cannot delete the 'default' namespace".to_string(),
));
}
let conn = self.lock_conn()?;
conn.execute(
"DELETE FROM refs WHERE namespace = ?1",
[namespace.as_str()],
)
.map_err(|e| StorageError::Backend(e.to_string()))?;
let rows = conn
.execute(
"DELETE FROM namespaces WHERE name = ?1",
[namespace.as_str()],
)
.map_err(|e| StorageError::Backend(e.to_string()))?;
Ok(rows > 0)
}
}
const PUT_OBJECT: &str = "INSERT INTO objects (id, data, written_at) VALUES (?1, ?2, ?3) \
ON CONFLICT(id) DO UPDATE SET written_at = excluded.written_at \
WHERE objects.written_at < excluded.written_at - ?4";
fn freshen_after_millis() -> i64 {
GC_FRESHEN_AFTER.as_millis() as i64
}
fn now_millis() -> i64 {
chrono::Utc::now().timestamp_millis()
}
const GC_SQL_CHUNK: usize = 400;
fn require_namespace(conn: &Connection, namespace: &Namespace) -> Result<(), StorageError> {
let exists: bool = conn
.query_row(
"SELECT EXISTS(SELECT 1 FROM namespaces WHERE name = ?1)",
params![namespace.as_str()],
|row| row.get(0),
)
.map_err(|e| StorageError::Backend(format!("check namespace: {}", e)))?;
if exists {
Ok(())
} else {
Err(StorageError::NamespaceNotFound(
namespace.as_str().to_string(),
))
}
}
fn gc_build_mark(conn: &Connection, roots: &[ObjectId], batch: i64) -> Result<(), StorageError> {
conn.execute_batch(
"CREATE TEMP TABLE IF NOT EXISTS gc_mark (id BLOB PRIMARY KEY, expanded INTEGER NOT NULL DEFAULT 0); \
CREATE INDEX IF NOT EXISTS gc_mark_expanded ON gc_mark(expanded); \
DELETE FROM gc_mark;",
)
.map_err(|e| StorageError::Backend(format!("gc_mark init: {}", e)))?;
for r in roots {
conn.execute(
"INSERT OR IGNORE INTO gc_mark (id, expanded) \
SELECT id, 0 FROM objects WHERE id = ?1",
params![r.as_bytes().as_slice()],
)
.map_err(|e| StorageError::Backend(format!("gc seed: {}", e)))?;
}
loop {
let frontier: Vec<(Vec<u8>, Option<Vec<u8>>)> = {
let mut stmt = conn
.prepare_cached(
"SELECT m.id, o.data FROM gc_mark m \
LEFT JOIN objects o ON o.id = m.id \
WHERE m.expanded = 0 LIMIT ?1",
)
.map_err(|e| StorageError::Backend(format!("gc frontier: {}", e)))?;
let rows = stmt
.query_map(params![batch], |row| {
Ok((row.get::<_, Vec<u8>>(0)?, row.get::<_, Option<Vec<u8>>>(1)?))
})
.map_err(|e| StorageError::Backend(format!("gc frontier q: {}", e)))?;
let mut v = Vec::new();
for r in rows {
v.push(r.map_err(|e| StorageError::Backend(format!("gc frontier row: {}", e)))?);
}
v
};
if frontier.is_empty() {
break;
}
let mut children: Vec<Vec<u8>> = Vec::new();
let mut expand_ids: Vec<Vec<u8>> = Vec::with_capacity(frontier.len());
for (id_bytes, data) in frontier {
if let Some(data) = &data {
let obj: Object = serde_json::from_slice(data)
.map_err(|e| StorageError::Serialization(e.to_string()))?;
for child in child_ids(&obj) {
children.push(child.as_bytes().to_vec());
}
}
expand_ids.push(id_bytes);
}
gc_in_tx(conn, "gc mark", |c| {
bulk_insert_marks(c, &children)?;
bulk_mark_expanded(c, &expand_ids)
})?;
}
Ok(())
}
fn gc_in_tx<T>(
conn: &Connection,
what: &str,
f: impl FnOnce(&Connection) -> Result<T, StorageError>,
) -> Result<T, StorageError> {
if !conn.is_autocommit() {
return f(conn);
}
let tx = conn
.unchecked_transaction()
.map_err(|e| StorageError::Backend(format!("{what} tx: {e}")))?;
let out = f(&tx)?;
tx.commit()
.map_err(|e| StorageError::Backend(format!("{what} commit: {e}")))?;
Ok(out)
}
fn gc_live_tip_roots(conn: &Connection) -> Result<Vec<ObjectId>, StorageError> {
let mut stmt = conn
.prepare("SELECT c.data FROM refs r JOIN commits c ON c.id = r.target")
.map_err(|e| StorageError::Backend(format!("gc tips read: {}", e)))?;
let rows = stmt
.query_map([], |row| row.get::<_, Vec<u8>>(0))
.map_err(|e| StorageError::Backend(format!("gc tips query: {}", e)))?;
let mut out = Vec::new();
for r in rows {
let data = r.map_err(|e| StorageError::Backend(format!("gc tip row: {}", e)))?;
let commit: Commit = serde_json::from_slice(&data)
.map_err(|e| StorageError::Serialization(e.to_string()))?;
out.push(commit.state_root);
}
Ok(out)
}
const GC_PIN_MAX_AGE: std::time::Duration = std::time::Duration::from_secs(24 * 60 * 60);
fn gc_pending_roots(
conn: &Connection,
max_age: std::time::Duration,
) -> Result<Vec<ObjectId>, StorageError> {
let cutoff = chrono::Utc::now().timestamp() - max_age.as_secs() as i64;
let mut stmt = conn
.prepare("SELECT root FROM gc_pending_roots WHERE updated_at >= ?1")
.map_err(|e| StorageError::Backend(format!("gc pinned roots: {}", e)))?;
let rows = stmt
.query_map(params![cutoff], |row| row.get::<_, Vec<u8>>(0))
.map_err(|e| StorageError::Backend(format!("gc pinned roots: {}", e)))?;
let mut out = Vec::new();
for bytes in rows {
let bytes = bytes.map_err(|e| StorageError::Backend(format!("gc pinned roots: {}", e)))?;
out.extend(object_id_from_bytes(&bytes));
}
Ok(out)
}
fn gc_sweep_locked(
conn: &Connection,
roots: &[ObjectId],
batch: i64,
grace: std::time::Duration,
) -> Result<GcSweep, StorageError> {
let cutoff = now_millis().saturating_sub(i64::try_from(grace.as_millis()).unwrap_or(i64::MAX));
let total_before: i64 = conn
.query_row("SELECT COUNT(*) FROM objects", [], |row| row.get(0))
.map_err(|e| StorageError::Backend(format!("gc sweep count: {}", e)))?;
let mut roots = roots.to_vec();
roots.extend(gc_live_tip_roots(conn)?);
roots.extend(gc_pending_roots(conn, GC_PIN_MAX_AGE)?);
gc_build_mark(conn, &roots, batch)?;
conn.execute_batch(
"CREATE TEMP TABLE IF NOT EXISTS gc_dead (id BLOB PRIMARY KEY); \
DELETE FROM gc_dead;",
)
.map_err(|e| StorageError::Backend(format!("gc dead set: {}", e)))?;
conn.execute(
"INSERT INTO gc_dead (id) \
SELECT o.id FROM objects o LEFT JOIN gc_mark m ON o.id = m.id \
WHERE m.id IS NULL AND o.written_at < ?1",
params![cutoff],
)
.map_err(|e| StorageError::Backend(format!("gc dead set: {}", e)))?;
let deleted_target: i64 = conn
.query_row("SELECT COUNT(*) FROM gc_dead", [], |row| row.get(0))
.map_err(|e| StorageError::Backend(format!("gc dead count: {}", e)))?;
let mut deleted = 0i64;
loop {
let dead: Vec<Vec<u8>> = {
let mut stmt = conn
.prepare_cached("SELECT id FROM gc_dead LIMIT ?1")
.map_err(|e| StorageError::Backend(format!("gc dead sel: {}", e)))?;
let rows = stmt
.query_map(params![batch], |row| row.get::<_, Vec<u8>>(0))
.map_err(|e| StorageError::Backend(format!("gc dead q: {}", e)))?;
let mut v = Vec::new();
for r in rows {
v.push(r.map_err(|e| StorageError::Backend(format!("gc dead row: {}", e)))?);
}
v
};
if dead.is_empty() {
break;
}
gc_bulk_delete(conn, "objects", &dead)?;
gc_bulk_delete(conn, "gc_dead", &dead)?;
deleted += dead.len() as i64;
}
conn.execute("DELETE FROM gc_mark", [])
.map_err(|e| StorageError::Backend(format!("gc mark cleanup: {}", e)))?;
let total_after: i64 = conn
.query_row("SELECT COUNT(*) FROM objects", [], |row| row.get(0))
.map_err(|e| StorageError::Backend(format!("gc after count: {}", e)))?;
Ok(GcSweep {
objects_before: total_before,
objects_deleted: deleted,
objects_after: total_after,
deleted_target,
})
}
fn gc_bulk_delete(tx: &Connection, table: &str, ids: &[Vec<u8>]) -> Result<(), StorageError> {
for chunk in ids.chunks(GC_SQL_CHUNK) {
let mut sql = format!("DELETE FROM {} WHERE id IN (", table);
for i in 0..chunk.len() {
if i > 0 {
sql.push(',');
}
sql.push('?');
}
sql.push(')');
tx.execute(
&sql,
rusqlite::params_from_iter(chunk.iter().map(|b| b.as_slice())),
)
.map_err(|e| StorageError::Backend(format!("gc bulk delete {}: {}", table, e)))?;
}
Ok(())
}
fn bulk_insert_marks(tx: &Connection, ids: &[Vec<u8>]) -> Result<(), StorageError> {
for chunk in ids.chunks(GC_SQL_CHUNK) {
let mut sql = String::from("INSERT OR IGNORE INTO gc_mark (id, expanded) VALUES ");
for i in 0..chunk.len() {
if i > 0 {
sql.push(',');
}
sql.push_str("(?, 0)");
}
tx.execute(
&sql,
rusqlite::params_from_iter(chunk.iter().map(|b| b.as_slice())),
)
.map_err(|e| StorageError::Backend(format!("gc bulk insert: {}", e)))?;
}
Ok(())
}
fn bulk_mark_expanded(tx: &Connection, ids: &[Vec<u8>]) -> Result<(), StorageError> {
for chunk in ids.chunks(GC_SQL_CHUNK) {
let mut sql = String::from("UPDATE gc_mark SET expanded = 1 WHERE id IN (");
for i in 0..chunk.len() {
if i > 0 {
sql.push(',');
}
sql.push('?');
}
sql.push(')');
tx.execute(
&sql,
rusqlite::params_from_iter(chunk.iter().map(|b| b.as_slice())),
)
.map_err(|e| StorageError::Backend(format!("gc bulk expand: {}", e)))?;
}
Ok(())
}
fn child_ids(obj: &Object) -> Vec<ObjectId> {
match obj {
Object::Node(Node::Map(entries)) => entries.values().copied().collect(),
Object::Node(Node::List(items)) | Object::Node(Node::Set(items)) => items.clone(),
Object::Atom(_) => Vec::new(),
}
}
fn object_id_from_bytes(bytes: &[u8]) -> Option<ObjectId> {
if bytes.len() != 32 {
return None;
}
let mut arr = [0u8; 32];
arr.copy_from_slice(bytes);
Some(ObjectId::from_bytes(arr))
}
fn epoch_status_str(s: &EpochStatus) -> &'static str {
match s {
EpochStatus::Active => "Active",
EpochStatus::Sealed => "Sealed",
EpochStatus::Archived => "Archived",
}
}
fn parse_epoch_status(s: &str) -> EpochStatus {
match s {
"Sealed" => EpochStatus::Sealed,
"Archived" => EpochStatus::Archived,
_ => EpochStatus::Active,
}
}
fn parse_rfc3339(s: &str) -> Result<DateTime<Utc>, StorageError> {
DateTime::parse_from_rfc3339(s)
.map(|dt| dt.with_timezone(&Utc))
.map_err(|e| StorageError::Serialization(format!("timestamp parse: {}", e)))
}
#[allow(clippy::too_many_arguments)]
fn row_to_epoch(
id: String,
description: String,
status: String,
created_at: String,
sealed_at: Option<String>,
summary: Option<String>,
root_intents: String,
agents: String,
tags: String,
sealed_commits: String,
seal_hash: Option<Vec<u8>>,
namespace: Option<String>,
scope: Option<String>,
) -> Result<Epoch, StorageError> {
let root_intents: Vec<String> = serde_json::from_str(&root_intents)
.map_err(|e| StorageError::Serialization(format!("root_intents: {}", e)))?;
let agents: Vec<String> = serde_json::from_str(&agents)
.map_err(|e| StorageError::Serialization(format!("agents: {}", e)))?;
let tags: Vec<String> = serde_json::from_str(&tags)
.map_err(|e| StorageError::Serialization(format!("tags: {}", e)))?;
let sealed_commits: Vec<ObjectId> = serde_json::from_str(&sealed_commits)
.map_err(|e| StorageError::Serialization(format!("sealed_commits: {}", e)))?;
Ok(Epoch {
id,
description,
root_intents,
status: parse_epoch_status(&status),
created_at: parse_rfc3339(&created_at)?,
sealed_at: sealed_at.as_deref().map(parse_rfc3339).transpose()?,
seal_summary: summary,
seal_hash: seal_hash.and_then(|b| {
<[u8; 32]>::try_from(b.as_slice())
.ok()
.map(ObjectId::from_bytes)
}),
commits: Vec::new(),
agents,
branches: Vec::new(),
scope: scope
.as_deref()
.map(EpochScope::from_storage_str)
.unwrap_or_default(),
namespace,
tags,
sealed_commits,
})
}
impl EpochStore for SqliteStorage {
fn create_epoch(&self, epoch: &Epoch) -> Result<(), StorageError> {
let conn = self.lock_conn()?;
let root_intents = serde_json::to_string(&epoch.root_intents)
.map_err(|e| StorageError::Serialization(e.to_string()))?;
let agents = serde_json::to_string(&epoch.agents)
.map_err(|e| StorageError::Serialization(e.to_string()))?;
let tags = serde_json::to_string(&epoch.tags)
.map_err(|e| StorageError::Serialization(e.to_string()))?;
let sealed_commits = serde_json::to_string(&epoch.sealed_commits)
.map_err(|e| StorageError::Serialization(e.to_string()))?;
conn.execute(
"INSERT INTO epochs
(id, description, status, created_at, sealed_at, summary,
root_intents, agents, tags, commit_count, sealed_commits,
namespace, scope)
VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13)",
params![
epoch.id,
epoch.description,
epoch_status_str(&epoch.status),
epoch.created_at.to_rfc3339(),
epoch.sealed_at.map(|t| t.to_rfc3339()),
epoch.seal_summary,
root_intents,
agents,
tags,
epoch.commits.len() as i64,
sealed_commits,
epoch.namespace,
epoch.scope.as_storage_str(),
],
)
.map_err(|e| StorageError::Backend(format!("create epoch: {}", e)))?;
Ok(())
}
fn seal_epoch(
&self,
id: &str,
summary: &str,
sealed_at: DateTime<Utc>,
sealed_commits: &[ObjectId],
seal_hash: &ObjectId,
) -> Result<(), StorageError> {
let conn = self.lock_conn()?;
let sc_json = serde_json::to_string(sealed_commits)
.map_err(|e| StorageError::Serialization(e.to_string()))?;
let sealed = conn
.execute(
"UPDATE epochs
SET status = 'Sealed', sealed_at = ?1, summary = ?2, sealed_commits = ?3,
seal_hash = ?4, commit_count = ?5
WHERE id = ?6 AND status NOT IN ('Sealed', 'Archived')",
params![
sealed_at.to_rfc3339(),
summary,
sc_json,
seal_hash.as_bytes().to_vec(),
sealed_commits.len() as i64,
id
],
)
.map_err(|e| StorageError::Backend(format!("seal epoch: {}", e)))?;
if sealed > 0 {
return Ok(());
}
let exists: Option<i64> = conn
.query_row("SELECT 1 FROM epochs WHERE id = ?1", params![id], |row| {
row.get(0)
})
.optional()
.map_err(|e| StorageError::Backend(format!("seal lookup: {}", e)))?;
match exists {
Some(_) => Err(StorageError::EpochAlreadySealed { id: id.to_string() }),
None => Err(StorageError::Backend(format!("epoch not found: {}", id))),
}
}
fn assign_epoch_namespace(&self, id: &str, namespace: &str) -> Result<bool, StorageError> {
let conn = self.lock_conn()?;
let changed = conn
.execute(
"UPDATE epochs SET namespace = ?1 WHERE id = ?2 AND namespace IS NULL",
params![namespace, id],
)
.map_err(|e| StorageError::Backend(format!("assign epoch namespace: {}", e)))?;
if changed > 0 {
return Ok(true);
}
let exists: bool = conn
.query_row(
"SELECT EXISTS(SELECT 1 FROM epochs WHERE id = ?1)",
params![id],
|row| row.get(0),
)
.map_err(|e| StorageError::Backend(format!("assign epoch lookup: {}", e)))?;
if exists {
Ok(false)
} else {
Err(StorageError::Backend(format!("epoch not found: {}", id)))
}
}
fn list_epochs(&self) -> Result<Vec<Epoch>, StorageError> {
let conn = self.lock_conn()?;
let mut stmt = conn
.prepare(
"SELECT id, description, status, created_at, sealed_at, summary,
root_intents, agents, tags, sealed_commits,
seal_hash, namespace, scope
FROM epochs ORDER BY created_at DESC",
)
.map_err(|e| StorageError::Backend(format!("list epochs prep: {}", e)))?;
let rows = stmt
.query_map([], |row| {
Ok((
row.get::<_, String>(0)?,
row.get::<_, String>(1)?,
row.get::<_, String>(2)?,
row.get::<_, String>(3)?,
row.get::<_, Option<String>>(4)?,
row.get::<_, Option<String>>(5)?,
row.get::<_, String>(6)?,
row.get::<_, String>(7)?,
row.get::<_, String>(8)?,
row.get::<_, String>(9)?,
row.get::<_, Option<Vec<u8>>>(10)?,
row.get::<_, Option<String>>(11)?,
row.get::<_, Option<String>>(12)?,
))
})
.map_err(|e| StorageError::Backend(format!("list epochs query: {}", e)))?;
let mut out = Vec::new();
for r in rows {
let (id, desc, status, created_at, sealed_at, summary, ri, ag, tg, sc, sh, ns, scp) =
r.map_err(|e| StorageError::Backend(format!("list epochs row: {}", e)))?;
out.push(row_to_epoch(
id, desc, status, created_at, sealed_at, summary, ri, ag, tg, sc, sh, ns, scp,
)?);
}
Ok(out)
}
fn get_epoch(&self, id: &str) -> Result<Option<Epoch>, StorageError> {
let conn = self.lock_conn()?;
type EpochRow = (
String,
String,
String,
String,
Option<String>,
Option<String>,
String,
String,
String,
String,
Option<Vec<u8>>,
Option<String>,
Option<String>,
);
let row: Option<EpochRow> = conn
.query_row(
"SELECT id, description, status, created_at, sealed_at, summary,
root_intents, agents, tags, sealed_commits,
seal_hash, namespace, scope
FROM epochs WHERE id = ?1",
params![id],
|row| {
Ok((
row.get(0)?,
row.get(1)?,
row.get(2)?,
row.get(3)?,
row.get(4)?,
row.get(5)?,
row.get(6)?,
row.get(7)?,
row.get(8)?,
row.get(9)?,
row.get(10)?,
row.get(11)?,
row.get(12)?,
))
},
)
.optional()
.map_err(|e| StorageError::Backend(format!("get epoch: {}", e)))?;
match row {
None => Ok(None),
Some((
id,
desc,
status,
created_at,
sealed_at,
summary,
ri,
ag,
tg,
sc,
sh,
ns,
scp,
)) => {
let mut epoch = row_to_epoch(
id, desc, status, created_at, sealed_at, summary, ri, ag, tg, sc, sh, ns, scp,
)?;
let mut stmt = conn
.prepare("SELECT id FROM commits WHERE epoch_id = ?1 ORDER BY rowid")
.map_err(|e| StorageError::Backend(format!("prepare epoch commits: {}", e)))?;
let commit_ids: Vec<ObjectId> = stmt
.query_map(params![epoch.id], |row| {
let bytes: Vec<u8> = row.get(0)?;
Ok(bytes)
})
.map_err(|e| StorageError::Backend(format!("query epoch commits: {}", e)))?
.filter_map(|r| r.ok())
.filter_map(|b| {
if b.len() == 32 {
let mut arr = [0u8; 32];
arr.copy_from_slice(&b);
Some(ObjectId::from_bytes(arr))
} else {
None
}
})
.collect();
epoch.commits = commit_ids;
Ok(Some(epoch))
}
}
}
fn archive_epoch(&self, id: &str) -> Result<(), StorageError> {
let conn = self.lock_conn()?;
let rows = conn
.execute(
"UPDATE epochs SET status = 'Archived' WHERE id = ?1 AND status = 'Sealed'",
params![id],
)
.map_err(|e| StorageError::Backend(format!("archive epoch: {}", e)))?;
if rows == 0 {
return Err(StorageError::Backend(format!(
"epoch '{}' not found or not sealed",
id
)));
}
Ok(())
}
fn set_commit_epoch(&self, commit_id: &ObjectId, epoch_id: &str) -> Result<(), StorageError> {
let mut conn = self.lock_conn()?;
let conn = conn
.transaction_with_behavior(rusqlite::TransactionBehavior::Immediate)
.map_err(|e| StorageError::Backend(format!("begin assoc: {}", e)))?;
let status: Option<String> = conn
.query_row(
"SELECT status FROM epochs WHERE id = ?1",
params![epoch_id],
|row| row.get(0),
)
.optional()
.map_err(|e| StorageError::Backend(format!("assoc lookup: {}", e)))?;
match status.as_deref() {
None => {
return Err(StorageError::Backend(format!(
"epoch not found: {}",
epoch_id
)));
}
Some("Sealed") | Some("Archived") => {
return Err(StorageError::EpochAlreadySealed {
id: epoch_id.to_string(),
});
}
_ => {}
}
let joined = conn
.execute(
"UPDATE commits SET epoch_id = ?1
WHERE id = ?2 AND epoch_id IS NOT ?1",
params![epoch_id, commit_id.as_bytes().as_slice()],
)
.map_err(|e| StorageError::Backend(format!("set commit epoch: {}", e)))?;
if joined > 0 {
conn.execute(
"UPDATE epochs SET commit_count = commit_count + 1 WHERE id = ?1",
params![epoch_id],
)
.map_err(|e| StorageError::Backend(format!("update commit_count: {}", e)))?;
}
conn.commit()
.map_err(|e| StorageError::Backend(format!("commit assoc: {}", e)))?;
Ok(())
}
}
#[allow(clippy::too_many_arguments)]
fn row_to_session(
id: String,
agent_id: String,
parent_id: Option<String>,
scope_path: Option<String>,
scope_branch: Option<String>,
scope_namespace: Option<String>,
status: String,
created_at: String,
ended_at: Option<String>,
metadata: String,
) -> Result<Session, StorageError> {
#[derive(serde::Deserialize, Default)]
struct Meta {
#[serde(default)]
head: Option<ObjectId>,
#[serde(default)]
delegated_intent: Option<String>,
#[serde(default)]
report_to: Option<String>,
#[serde(default)]
working_branch: Option<String>,
#[serde(default)]
scope_tenant: Option<String>,
}
let meta: Meta = serde_json::from_str(&metadata).unwrap_or_default();
let head = meta.head.unwrap_or_else(|| ObjectId::hash(b""));
let working_branch = meta
.working_branch
.unwrap_or_else(|| scope_branch.clone().unwrap_or_default());
Ok(Session {
id,
agent_id,
working_branch,
head,
parent_session: parent_id,
delegated_intent: meta.delegated_intent,
report_to: meta.report_to,
path_scope: scope_path,
scope_tenant: meta.scope_tenant,
scope_namespace: scope_namespace
.as_deref()
.and_then(|s| Namespace::new(s).ok()),
status: SessionStatus::from_wire(&status),
created_at: parse_rfc3339(&created_at)?,
ended_at: ended_at.as_deref().map(parse_rfc3339).transpose()?,
})
}
impl SessionStore for SqliteStorage {
fn create_session(&self, session: &Session) -> Result<(), StorageError> {
let conn = self.lock_conn()?;
let metadata = serde_json::json!({
"head": session.head,
"delegated_intent": session.delegated_intent,
"report_to": session.report_to,
"working_branch": session.working_branch,
"scope_tenant": session.scope_tenant,
})
.to_string();
conn.execute(
"INSERT OR REPLACE INTO sessions
(id, agent_id, parent_id, scope_path, scope_branch, scope_namespace,
status, created_at, ended_at, metadata, commit_count)
VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10,
COALESCE((SELECT commit_count FROM sessions WHERE id = ?1), 0))",
params![
session.id,
session.agent_id,
session.parent_session,
session.path_scope,
session.working_branch,
session.scope_namespace.as_ref().map(|n| n.as_str()),
session.status.as_str(),
session.created_at.to_rfc3339(),
session.ended_at.map(|t| t.to_rfc3339()),
metadata,
],
)
.map_err(|e| StorageError::Backend(format!("create session: {}", e)))?;
Ok(())
}
fn end_session(
&self,
id: &str,
status: SessionStatus,
ended_at: DateTime<Utc>,
) -> Result<(), StorageError> {
let conn = self.lock_conn()?;
let ended = conn
.execute(
"UPDATE sessions SET status = ?1, ended_at = ?2
WHERE id = ?3 AND status = 'Active'",
params![status.as_str(), ended_at.to_rfc3339(), id],
)
.map_err(|e| StorageError::Backend(format!("end session: {}", e)))?;
if ended > 0 {
return Ok(());
}
let exists: Option<i64> = conn
.query_row("SELECT 1 FROM sessions WHERE id = ?1", params![id], |row| {
row.get(0)
})
.optional()
.map_err(|e| StorageError::Backend(format!("end session lookup: {}", e)))?;
match exists {
Some(_) => Err(StorageError::SessionEnded { id: id.to_string() }),
None => Err(StorageError::Backend(format!("session not found: {}", id))),
}
}
fn list_sessions(&self, agent_filter: Option<&str>) -> Result<Vec<Session>, StorageError> {
let conn = self.lock_conn()?;
let mut stmt = conn
.prepare(
"SELECT id, agent_id, parent_id, scope_path, scope_branch, scope_namespace,
status, created_at, ended_at, metadata
FROM sessions
WHERE (?1 IS NULL OR agent_id = ?1)
ORDER BY created_at DESC",
)
.map_err(|e| StorageError::Backend(format!("list sessions prep: {}", e)))?;
let rows = stmt
.query_map(params![agent_filter], |row| {
Ok((
row.get::<_, String>(0)?,
row.get::<_, String>(1)?,
row.get::<_, Option<String>>(2)?,
row.get::<_, Option<String>>(3)?,
row.get::<_, Option<String>>(4)?,
row.get::<_, Option<String>>(5)?,
row.get::<_, String>(6)?,
row.get::<_, String>(7)?,
row.get::<_, Option<String>>(8)?,
row.get::<_, String>(9)?,
))
})
.map_err(|e| StorageError::Backend(format!("list sessions query: {}", e)))?;
let mut out = Vec::new();
for r in rows {
let (id, agent, parent, sp, sb, sns, st, ca, ea, md) =
r.map_err(|e| StorageError::Backend(format!("list sessions row: {}", e)))?;
out.push(row_to_session(
id, agent, parent, sp, sb, sns, st, ca, ea, md,
)?);
}
Ok(out)
}
fn get_session(&self, id: &str) -> Result<Option<Session>, StorageError> {
let conn = self.lock_conn()?;
type SessionRow = (
String,
String,
Option<String>,
Option<String>,
Option<String>,
Option<String>,
String,
String,
Option<String>,
String,
);
let row: Option<SessionRow> = conn
.query_row(
"SELECT id, agent_id, parent_id, scope_path, scope_branch, scope_namespace,
status, created_at, ended_at, metadata
FROM sessions WHERE id = ?1",
params![id],
|row| {
Ok((
row.get(0)?,
row.get(1)?,
row.get(2)?,
row.get(3)?,
row.get(4)?,
row.get(5)?,
row.get(6)?,
row.get(7)?,
row.get(8)?,
row.get(9)?,
))
},
)
.optional()
.map_err(|e| StorageError::Backend(format!("get session: {}", e)))?;
match row {
None => Ok(None),
Some((id, agent, parent, sp, sb, sns, st, ca, ea, md)) => Ok(Some(row_to_session(
id, agent, parent, sp, sb, sns, st, ca, ea, md,
)?)),
}
}
fn set_commit_session(
&self,
commit_id: &ObjectId,
session_id: &str,
) -> Result<(), StorageError> {
let mut conn = self.lock_conn()?;
let conn = conn
.transaction_with_behavior(rusqlite::TransactionBehavior::Immediate)
.map_err(|e| StorageError::Backend(format!("begin assoc: {}", e)))?;
let status: Option<String> = conn
.query_row(
"SELECT status FROM sessions WHERE id = ?1",
params![session_id],
|row| row.get(0),
)
.optional()
.map_err(|e| StorageError::Backend(format!("assoc lookup: {}", e)))?;
match status.as_deref() {
None => {
return Err(StorageError::Backend(format!(
"session not found: {}",
session_id
)));
}
Some(s) if s != "Active" => {
return Err(StorageError::SessionEnded {
id: session_id.to_string(),
});
}
_ => {}
}
let joined = conn
.execute(
"UPDATE commits SET session_id = ?1
WHERE id = ?2 AND session_id IS NOT ?1",
params![session_id, commit_id.as_bytes().as_slice()],
)
.map_err(|e| StorageError::Backend(format!("set commit session: {}", e)))?;
if joined > 0 {
conn.execute(
"UPDATE sessions SET commit_count = commit_count + 1 WHERE id = ?1",
params![session_id],
)
.map_err(|e| StorageError::Backend(format!("update session commit_count: {}", e)))?;
}
conn.commit()
.map_err(|e| StorageError::Backend(format!("commit assoc: {}", e)))?;
Ok(())
}
}
fn kind_to_str(k: TaintKind) -> &'static str {
match k {
TaintKind::Taint => "taint",
TaintKind::Quarantine => "quarantine",
TaintKind::Watch => "watch",
}
}
fn kind_from_str(s: &str) -> Result<TaintKind, StorageError> {
match s {
"taint" => Ok(TaintKind::Taint),
"quarantine" => Ok(TaintKind::Quarantine),
"watch" => Ok(TaintKind::Watch),
other => Err(StorageError::Backend(format!(
"unknown taint kind: {other}"
))),
}
}
fn effect_to_str(e: TaintEffect) -> &'static str {
match e {
TaintEffect::Warn => "warn",
TaintEffect::Block => "block",
TaintEffect::Review => "review",
TaintEffect::Isolate => "isolate",
TaintEffect::Advisory => "advisory",
}
}
fn effect_from_str(s: &str) -> Result<TaintEffect, StorageError> {
match s {
"warn" => Ok(TaintEffect::Warn),
"block" => Ok(TaintEffect::Block),
"review" => Ok(TaintEffect::Review),
"isolate" => Ok(TaintEffect::Isolate),
"advisory" => Ok(TaintEffect::Advisory),
other => Err(StorageError::Backend(format!(
"unknown taint effect: {other}"
))),
}
}
fn severity_to_str(s: TaintSeverity) -> &'static str {
match s {
TaintSeverity::Low => "low",
TaintSeverity::Medium => "medium",
TaintSeverity::High => "high",
TaintSeverity::Critical => "critical",
}
}
fn severity_from_str(s: &str) -> Result<TaintSeverity, StorageError> {
match s {
"low" => Ok(TaintSeverity::Low),
"medium" => Ok(TaintSeverity::Medium),
"high" => Ok(TaintSeverity::High),
"critical" => Ok(TaintSeverity::Critical),
other => Err(StorageError::Backend(format!(
"unknown taint severity: {other}"
))),
}
}
fn row_to_taint(row: &Row<'_>) -> rusqlite::Result<Taint> {
use rusqlite::types::{FromSqlError, Type};
fn decode_err<E: std::fmt::Display>(col: usize, ty: Type, e: E) -> rusqlite::Error {
rusqlite::Error::FromSqlConversionFailure(
col,
ty,
Box::new(FromSqlError::Other(format!("{e}").into())),
)
}
let kind: String = row.get("kind")?;
let effect: String = row.get("effect")?;
let severity: String = row.get("severity")?;
let metadata_raw: String = row.get("metadata")?;
let created_at_s: String = row.get("created_at")?;
let expires_at_s: Option<String> = row.get("expires_at")?;
let resolved_at_s: Option<String> = row.get("resolved_at")?;
let metadata: TaintMetadata = serde_json::from_str(&metadata_raw)
.map_err(|e| decode_err(0, Type::Text, format!("taint metadata: {e}")))?;
let created_at = DateTime::parse_from_rfc3339(&created_at_s)
.map_err(|e| decode_err(0, Type::Text, format!("created_at: {e}")))?
.with_timezone(&Utc);
let expires_at = match expires_at_s {
Some(s) => Some(
DateTime::parse_from_rfc3339(&s)
.map_err(|e| decode_err(0, Type::Text, format!("expires_at: {e}")))?
.with_timezone(&Utc),
),
None => None,
};
let resolved_at = match resolved_at_s {
Some(s) => Some(
DateTime::parse_from_rfc3339(&s)
.map_err(|e| decode_err(0, Type::Text, format!("resolved_at: {e}")))?
.with_timezone(&Utc),
),
None => None,
};
let kind = kind_from_str(&kind).map_err(|e| decode_err(0, Type::Text, e.to_string()))?;
let effect = effect_from_str(&effect).map_err(|e| decode_err(0, Type::Text, e.to_string()))?;
let severity =
severity_from_str(&severity).map_err(|e| decode_err(0, Type::Text, e.to_string()))?;
Ok(Taint {
id: row.get("id")?,
path: row.get("path")?,
name: row.get("name")?,
kind,
effect,
severity,
reason: row.get("reason")?,
agent_id: row.get("agent_id")?,
commit_id: row.get("commit_id")?,
created_at,
expires_at,
resolved_at,
resolved_by: row.get("resolved_by")?,
resolved_reason: row.get("resolved_reason")?,
resolved_proof: row.get("resolved_proof")?,
propagate: row.get::<_, i64>("propagate")? != 0,
metadata,
})
}
impl TaintStore for SqliteStorage {
fn create_taint(&self, taint: &Taint) -> Result<(), StorageError> {
let conn = self.lock_conn()?;
let metadata_json = serde_json::to_string(&taint.metadata)
.map_err(|e| StorageError::Serialization(format!("taint metadata: {e}")))?;
conn.execute(
"INSERT INTO taints (
id, path, name, kind, effect, severity, reason, agent_id,
commit_id, created_at, expires_at, resolved_at, resolved_by,
resolved_reason, resolved_proof, propagate, metadata
) VALUES (
?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8,
?9, ?10, ?11, ?12, ?13, ?14, ?15, ?16, ?17
)",
params![
taint.id,
taint.path,
taint.name,
kind_to_str(taint.kind),
effect_to_str(taint.effect),
severity_to_str(taint.severity),
taint.reason,
taint.agent_id,
taint.commit_id,
taint.created_at.to_rfc3339(),
taint.expires_at.map(|t| t.to_rfc3339()),
taint.resolved_at.map(|t| t.to_rfc3339()),
taint.resolved_by,
taint.resolved_reason,
taint.resolved_proof,
if taint.propagate { 1_i64 } else { 0_i64 },
metadata_json,
],
)
.map_err(|e| StorageError::Backend(format!("insert taint: {e}")))?;
Ok(())
}
fn resolve_taint(
&self,
id: &str,
resolved_by: &str,
reason: &str,
proof: Option<&str>,
resolved_at: DateTime<Utc>,
) -> Result<(), StorageError> {
let conn = self.lock_conn()?;
let already: Option<String> = conn
.query_row(
"SELECT resolved_at FROM taints WHERE id = ?1",
params![id],
|row| row.get(0),
)
.optional()
.map_err(|e| StorageError::Backend(format!("resolve check: {e}")))?
.ok_or_else(|| StorageError::Backend(format!("taint {id} not found")))?;
if already.is_some() {
return Err(StorageError::Backend(format!(
"taint {id} is already resolved"
)));
}
conn.execute(
"UPDATE taints SET resolved_at = ?1, resolved_by = ?2,
resolved_reason = ?3, resolved_proof = ?4
WHERE id = ?5",
params![resolved_at.to_rfc3339(), resolved_by, reason, proof, id],
)
.map_err(|e| StorageError::Backend(format!("resolve taint: {e}")))?;
Ok(())
}
fn list_taints(
&self,
path_prefix: Option<&str>,
kind: Option<TaintKind>,
include_resolved: bool,
) -> Result<Vec<Taint>, StorageError> {
let conn = self.lock_conn()?;
let mut sql = String::from("SELECT * FROM taints WHERE 1=1");
if !include_resolved {
sql.push_str(" AND resolved_at IS NULL");
}
if let Some(_p) = path_prefix {
sql.push_str(" AND (path = :p OR path LIKE :plike)");
}
if kind.is_some() {
sql.push_str(" AND kind = :k");
}
sql.push_str(" ORDER BY created_at DESC");
let mut stmt = conn
.prepare(&sql)
.map_err(|e| StorageError::Backend(format!("list taints prep: {e}")))?;
let mut params_named: Vec<(&str, Box<dyn rusqlite::ToSql>)> = Vec::new();
let plike;
if let Some(p) = path_prefix {
let p = p.trim_end_matches('/');
plike = format!("{}/%", p);
params_named.push((":p", Box::new(p.to_string())));
params_named.push((":plike", Box::new(plike.clone())));
}
if let Some(k) = kind {
params_named.push((":k", Box::new(kind_to_str(k).to_string())));
}
let refs: Vec<(&str, &dyn rusqlite::ToSql)> =
params_named.iter().map(|(n, v)| (*n, v.as_ref())).collect();
let rows = stmt
.query_map(refs.as_slice(), row_to_taint)
.map_err(|e| StorageError::Backend(format!("list taints query: {e}")))?;
let mut out = Vec::new();
for r in rows {
out.push(r.map_err(|e| StorageError::Backend(format!("list taints row: {e}")))?);
}
Ok(out)
}
fn check_taint(&self, request_path: &str) -> Result<Vec<Taint>, StorageError> {
let conn = self.lock_conn()?;
let now = Utc::now().to_rfc3339();
let mut stmt = conn
.prepare(
"SELECT * FROM taints
WHERE resolved_at IS NULL
AND (expires_at IS NULL OR expires_at > :now)
AND (path = :path
OR (propagate = 1 AND :path LIKE path || '/%'))
ORDER BY created_at DESC",
)
.map_err(|e| StorageError::Backend(format!("check_taint prep: {e}")))?;
let rows = stmt
.query_map(
&[
(":now", &now as &dyn rusqlite::ToSql),
(":path", &request_path),
],
row_to_taint,
)
.map_err(|e| StorageError::Backend(format!("check_taint query: {e}")))?;
let mut out = Vec::new();
for r in rows {
out.push(r.map_err(|e| StorageError::Backend(format!("check_taint row: {e}")))?);
}
Ok(out)
}
fn get_taint(&self, id: &str) -> Result<Option<Taint>, StorageError> {
let conn = self.lock_conn()?;
let mut stmt = conn
.prepare("SELECT * FROM taints WHERE id = ?1")
.map_err(|e| StorageError::Backend(format!("get_taint prep: {e}")))?;
let t = stmt
.query_row(params![id], row_to_taint)
.optional()
.map_err(|e| StorageError::Backend(format!("get_taint: {e}")))?;
Ok(t)
}
fn set_taint_commit_id(&self, id: &str, commit_id: &str) -> Result<(), StorageError> {
let conn = self.lock_conn()?;
conn.execute(
"UPDATE taints SET commit_id = ?1 WHERE id = ?2 AND resolved_at IS NULL",
params![commit_id, id],
)
.map_err(|e| StorageError::Backend(format!("set_taint_commit_id: {e}")))?;
Ok(())
}
}
fn reminder_status_to_str(s: ReminderStatus) -> &'static str {
match s {
ReminderStatus::Pending => "pending",
ReminderStatus::Due => "due",
ReminderStatus::AwaitingPermission => "awaiting_permission",
ReminderStatus::InProgress => "in_progress",
ReminderStatus::Completed => "completed",
ReminderStatus::Snoozed => "snoozed",
ReminderStatus::Cancelled => "cancelled",
}
}
fn reminder_status_from_str(s: &str) -> Result<ReminderStatus, ReminderError> {
match s {
"pending" => Ok(ReminderStatus::Pending),
"due" => Ok(ReminderStatus::Due),
"awaiting_permission" => Ok(ReminderStatus::AwaitingPermission),
"in_progress" => Ok(ReminderStatus::InProgress),
"completed" => Ok(ReminderStatus::Completed),
"snoozed" => Ok(ReminderStatus::Snoozed),
"cancelled" => Ok(ReminderStatus::Cancelled),
other => Err(ReminderError::Store(format!(
"unknown reminder status: {other}"
))),
}
}
fn priority_to_i64(p: Priority) -> i64 {
p.as_u8() as i64
}
fn priority_from_i64(n: i64) -> Result<Priority, ReminderError> {
match n {
1 => Ok(Priority::Critical),
2 => Ok(Priority::High),
3 => Ok(Priority::Medium),
4 => Ok(Priority::Low),
5 => Ok(Priority::Minimal),
other => Err(ReminderError::Store(format!(
"unknown priority value: {other}"
))),
}
}
fn row_to_reminder(row: &Row<'_>) -> rusqlite::Result<Reminder> {
use rusqlite::types::{FromSqlError, Type};
fn decode_err<E: std::fmt::Display>(e: E) -> rusqlite::Error {
rusqlite::Error::FromSqlConversionFailure(
0,
Type::Text,
Box::new(FromSqlError::Other(format!("{e}").into())),
)
}
let status_s: String = row.get("status")?;
let priority_n: i64 = row.get("priority")?;
let due_at_s: String = row.get("due_at")?;
let created_at_s: String = row.get("created_at")?;
let snoozed_until_s: Option<String> = row.get("snoozed_until")?;
let commands_s: String = row.get("commands")?;
let refs_s: String = row.get("refs")?;
let schedule_s: Option<String> = row.get("schedule")?;
let executions_s: String = row.get("executions")?;
let tags_s: String = row.get("tags")?;
let autonomous: i64 = row.get("autonomous")?;
let status = reminder_status_from_str(&status_s).map_err(|e| decode_err(e))?;
let priority = priority_from_i64(priority_n).map_err(|e| decode_err(e))?;
let due_at = DateTime::parse_from_rfc3339(&due_at_s)
.map_err(|e| decode_err(format!("due_at: {e}")))?
.with_timezone(&Utc);
let created_at = DateTime::parse_from_rfc3339(&created_at_s)
.map_err(|e| decode_err(format!("created_at: {e}")))?
.with_timezone(&Utc);
let snoozed_until = match snoozed_until_s {
Some(s) => Some(
DateTime::parse_from_rfc3339(&s)
.map_err(|e| decode_err(format!("snoozed_until: {e}")))?
.with_timezone(&Utc),
),
None => None,
};
let commands: Vec<String> =
serde_json::from_str(&commands_s).map_err(|e| decode_err(format!("commands: {e}")))?;
let refs = serde_json::from_str(&refs_s).map_err(|e| decode_err(format!("refs: {e}")))?;
let schedule = match schedule_s {
Some(s) => {
Some(serde_json::from_str(&s).map_err(|e| decode_err(format!("schedule: {e}")))?)
}
None => None,
};
let executions: Vec<agentstategraph_reminders::types::ExecutionRecord> =
serde_json::from_str(&executions_s).map_err(|e| decode_err(format!("executions: {e}")))?;
let tags: Vec<String> =
serde_json::from_str(&tags_s).map_err(|e| decode_err(format!("tags: {e}")))?;
Ok(Reminder {
id: row.get("id")?,
title: row.get("title")?,
instructions: row.get("instructions")?,
commands,
refs,
priority,
due_at,
schedule,
autonomous: autonomous != 0,
created_by: row.get("created_by")?,
created_at,
status,
snoozed_until,
executions,
tags,
})
}
impl ReminderStore for SqliteStorage {
fn save(&self, reminder: &Reminder) -> Result<(), ReminderError> {
let conn = self
.lock_conn()
.map_err(|e| ReminderError::Store(e.to_string()))?;
let commands_json = serde_json::to_string(&reminder.commands)
.map_err(|e| ReminderError::Store(format!("commands: {e}")))?;
let refs_json = serde_json::to_string(&reminder.refs)
.map_err(|e| ReminderError::Store(format!("refs: {e}")))?;
let schedule_json = reminder
.schedule
.as_ref()
.map(|s| serde_json::to_string(s))
.transpose()
.map_err(|e| ReminderError::Store(format!("schedule: {e}")))?;
let executions_json = serde_json::to_string(&reminder.executions)
.map_err(|e| ReminderError::Store(format!("executions: {e}")))?;
let tags_json = serde_json::to_string(&reminder.tags)
.map_err(|e| ReminderError::Store(format!("tags: {e}")))?;
conn.execute(
"INSERT INTO reminders (
id, title, instructions, commands, refs, priority, due_at,
schedule, autonomous, created_by, created_at, status,
snoozed_until, executions, tags
) VALUES (
?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14, ?15
)",
params![
reminder.id,
reminder.title,
reminder.instructions,
commands_json,
refs_json,
priority_to_i64(reminder.priority),
reminder.due_at.to_rfc3339(),
schedule_json,
if reminder.autonomous { 1_i64 } else { 0_i64 },
reminder.created_by,
reminder.created_at.to_rfc3339(),
reminder_status_to_str(reminder.status),
reminder.snoozed_until.map(|t| t.to_rfc3339()),
executions_json,
tags_json,
],
)
.map_err(|e| ReminderError::Store(format!("insert reminder: {e}")))?;
Ok(())
}
fn get(&self, id: &str) -> Result<Option<Reminder>, ReminderError> {
let conn = self
.lock_conn()
.map_err(|e| ReminderError::Store(e.to_string()))?;
let mut stmt = conn
.prepare("SELECT * FROM reminders WHERE id = ?1")
.map_err(|e| ReminderError::Store(format!("get reminder prep: {e}")))?;
let result = stmt
.query_row(params![id], row_to_reminder)
.optional()
.map_err(|e| ReminderError::Store(format!("get reminder: {e}")))?;
Ok(result)
}
fn update(&self, reminder: &Reminder) -> Result<(), ReminderError> {
let conn = self
.lock_conn()
.map_err(|e| ReminderError::Store(e.to_string()))?;
update_reminder_on(&conn, reminder)
}
fn update_if_unchanged(
&self,
expected: &Reminder,
new: &Reminder,
) -> Result<bool, ReminderError> {
let mut conn = self
.lock_conn()
.map_err(|e| ReminderError::Store(e.to_string()))?;
let tx = conn
.transaction_with_behavior(rusqlite::TransactionBehavior::Immediate)
.map_err(|e| ReminderError::Store(format!("begin reminder update: {e}")))?;
let current = tx
.query_row(
"SELECT * FROM reminders WHERE id = ?1",
params![expected.id],
row_to_reminder,
)
.optional()
.map_err(|e| ReminderError::Store(format!("get reminder: {e}")))?;
match current {
None => Err(ReminderError::NotFound(expected.id.clone())),
Some(current) if !agentstategraph_reminders::same_reminder(¤t, expected) => {
Ok(false) }
Some(_) => {
update_reminder_on(&tx, new)?;
tx.commit()
.map_err(|e| ReminderError::Store(format!("commit reminder update: {e}")))?;
Ok(true)
}
}
}
fn delete(&self, id: &str) -> Result<bool, ReminderError> {
let conn = self
.lock_conn()
.map_err(|e| ReminderError::Store(e.to_string()))?;
let n = conn
.execute("DELETE FROM reminders WHERE id = ?1", params![id])
.map_err(|e| ReminderError::Store(format!("delete reminder: {e}")))?;
Ok(n > 0)
}
fn list(&self, filter: &ReminderFilter) -> Result<Vec<Reminder>, ReminderError> {
let conn = self
.lock_conn()
.map_err(|e| ReminderError::Store(e.to_string()))?;
let mut sql = String::from("SELECT * FROM reminders WHERE 1=1");
if filter.status.is_some() {
sql.push_str(" AND status = :status");
}
if filter.priority_at_most.is_some() {
sql.push_str(" AND priority <= :priority");
}
if filter.created_by.is_some() {
sql.push_str(" AND created_by = :created_by");
}
if filter.due_before.is_some() {
sql.push_str(" AND due_at <= :due_before");
}
sql.push_str(" ORDER BY priority ASC, due_at ASC");
let mut stmt = conn
.prepare(&sql)
.map_err(|e| ReminderError::Store(format!("list reminders prep: {e}")))?;
let mut named: Vec<(&str, Box<dyn rusqlite::ToSql>)> = Vec::new();
if let Some(s) = filter.status {
named.push((":status", Box::new(reminder_status_to_str(s).to_string())));
}
if let Some(p) = filter.priority_at_most {
named.push((":priority", Box::new(priority_to_i64(p))));
}
if let Some(ref cb) = filter.created_by {
named.push((":created_by", Box::new(cb.clone())));
}
if let Some(due) = filter.due_before {
named.push((":due_before", Box::new(due.to_rfc3339())));
}
let refs_kv: Vec<(&str, &dyn rusqlite::ToSql)> =
named.iter().map(|(n, v)| (*n, v.as_ref())).collect();
let rows = stmt
.query_map(refs_kv.as_slice(), row_to_reminder)
.map_err(|e| ReminderError::Store(format!("list reminders query: {e}")))?;
let mut out = Vec::new();
for r in rows {
let reminder =
r.map_err(|e| ReminderError::Store(format!("list reminders row: {e}")))?;
if let Some(ref rid) = filter.ref_id {
if !reminder.refs.iter().any(|rf| &rf.id == rid) {
continue;
}
}
if filter.tags.iter().any(|tag| !reminder.tags.contains(tag)) {
continue;
}
out.push(reminder);
}
Ok(out)
}
}
fn update_reminder_on(conn: &Connection, reminder: &Reminder) -> Result<(), ReminderError> {
let commands_json = serde_json::to_string(&reminder.commands)
.map_err(|e| ReminderError::Store(format!("commands: {e}")))?;
let refs_json = serde_json::to_string(&reminder.refs)
.map_err(|e| ReminderError::Store(format!("refs: {e}")))?;
let schedule_json = reminder
.schedule
.as_ref()
.map(serde_json::to_string)
.transpose()
.map_err(|e| ReminderError::Store(format!("schedule: {e}")))?;
let executions_json = serde_json::to_string(&reminder.executions)
.map_err(|e| ReminderError::Store(format!("executions: {e}")))?;
let tags_json = serde_json::to_string(&reminder.tags)
.map_err(|e| ReminderError::Store(format!("tags: {e}")))?;
let n = conn
.execute(
"UPDATE reminders SET
title = ?2, instructions = ?3, commands = ?4, refs = ?5,
priority = ?6, due_at = ?7, schedule = ?8, autonomous = ?9,
created_by = ?10, created_at = ?11, status = ?12,
snoozed_until = ?13, executions = ?14, tags = ?15
WHERE id = ?1",
params![
reminder.id,
reminder.title,
reminder.instructions,
commands_json,
refs_json,
priority_to_i64(reminder.priority),
reminder.due_at.to_rfc3339(),
schedule_json,
if reminder.autonomous { 1_i64 } else { 0_i64 },
reminder.created_by,
reminder.created_at.to_rfc3339(),
reminder_status_to_str(reminder.status),
reminder.snoozed_until.map(|t| t.to_rfc3339()),
executions_json,
tags_json,
],
)
.map_err(|e| ReminderError::Store(format!("update reminder: {e}")))?;
if n == 0 {
return Err(ReminderError::NotFound(reminder.id.clone()));
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use agentstategraph_core::*;
fn test_store() -> SqliteStorage {
SqliteStorage::in_memory().unwrap()
}
fn commit_with(store: &SqliteStorage, label: &str, parents: Vec<ObjectId>) -> Commit {
let c = CommitBuilder::new(
ObjectId::hash(label.as_bytes()),
"agent/test",
Authority::simple("test"),
Intent::new(IntentCategory::Checkpoint, label),
)
.parents(parents)
.build();
store.put_commit(&c).unwrap();
c
}
#[test]
fn dag_walk_reaches_the_second_parent_and_log_does_not() {
let store = test_store();
let base = commit_with(&store, "base", vec![]);
let left = commit_with(&store, "left", vec![base.id]);
let right = commit_with(&store, "right", vec![base.id]);
let merge = commit_with(&store, "merge", vec![left.id, right.id]);
let linear: Vec<ObjectId> = store
.list_commits(&merge.id, 100)
.unwrap()
.into_iter()
.map(|c| c.id)
.collect();
assert!(
!linear.contains(&right.id),
"first-parent walk must NOT reach the second parent — if it does, \
the bug this walk exists for is gone and this test is misleading"
);
let walk = store.list_commits_dag(&merge.id, 100).unwrap();
let ids: Vec<ObjectId> = walk.commits.iter().map(|c| c.id).collect();
for (name, id) in [
("merge", merge.id),
("left", left.id),
("right", right.id),
("base", base.id),
] {
assert!(ids.contains(&id), "DAG walk missed {name}");
}
assert!(!walk.truncated, "walk fit inside the limit");
}
#[test]
fn dag_walk_dedups_a_commit_reachable_from_both_sides() {
let store = test_store();
let base = commit_with(&store, "base", vec![]);
let left = commit_with(&store, "left", vec![base.id]);
let right = commit_with(&store, "right", vec![base.id]);
let merge = commit_with(&store, "merge", vec![left.id, right.id]);
let walk = store.list_commits_dag(&merge.id, 100).unwrap();
let n = walk.commits.iter().filter(|c| c.id == base.id).count();
assert_eq!(n, 1, "base reachable from both sides must appear once");
assert_eq!(walk.commits.len(), 4, "four distinct commits");
}
#[test]
fn dag_walk_reports_truncation_only_when_more_remained() {
let store = test_store();
let base = commit_with(&store, "base", vec![]);
let mid = commit_with(&store, "mid", vec![base.id]);
let tip = commit_with(&store, "tip", vec![mid.id]);
let capped = store.list_commits_dag(&tip.id, 2).unwrap();
assert_eq!(capped.commits.len(), 2);
assert!(capped.truncated, "stopped with a parent still unexplored");
let exact = store.list_commits_dag(&tip.id, 3).unwrap();
assert_eq!(exact.commits.len(), 3);
assert!(
!exact.truncated,
"a walk that consumed the whole DAG must NOT claim truncation, \
even when it used the limit exactly"
);
}
#[test]
fn dag_walk_survives_a_pruned_parent() {
let store = test_store();
let missing = ObjectId::hash(b"swept-away");
let real = commit_with(&store, "real", vec![]);
let tip = commit_with(&store, "tip", vec![missing, real.id]);
let walk = store.list_commits_dag(&tip.id, 100).unwrap();
let ids: Vec<ObjectId> = walk.commits.iter().map(|c| c.id).collect();
assert!(ids.contains(&tip.id));
assert!(
ids.contains(&real.id),
"the surviving edge must still be walked past a pruned parent"
);
assert!(
!ids.contains(&missing),
"a pruned commit cannot be returned"
);
}
#[test]
fn dag_walk_on_a_single_commit_is_complete() {
let store = test_store();
let only = commit_with(&store, "only", vec![]);
let walk = store.list_commits_dag(&only.id, 100).unwrap();
assert_eq!(walk.commits.len(), 1);
assert!(!walk.truncated);
}
#[test]
fn dag_walk_from_a_missing_commit_is_empty_not_an_error() {
let store = test_store();
let walk = store
.list_commits_dag(&ObjectId::hash(b"never-existed"), 100)
.unwrap();
assert!(walk.commits.is_empty());
assert!(!walk.truncated);
}
#[test]
fn unattributable_commits_are_not_filed_under_default() {
let store = test_store();
let c = CommitBuilder::new(
ObjectId::hash(b"state"),
"agent/test",
Authority::simple("test"),
Intent::new(IntentCategory::Checkpoint, "no session"),
)
.build();
store.put_commit(&c).unwrap();
assert!(store.history_extract_batch(100).unwrap() > 0);
let rows = store.history_rollup().unwrap();
assert_eq!(rows.len(), 1);
assert_eq!(
rows[0].namespace, HISTORY_NAMESPACE_UNKNOWN,
"a commit with no session must say so, not claim 'default'"
);
assert_ne!(
rows[0].namespace, "default",
"the old fallback asserted a namespace it had not established"
);
}
#[test]
fn test_object_roundtrip() {
let store = test_store();
let obj = Object::string("hello sqlite");
let id = store.put_object(&obj).unwrap();
let retrieved = store.get_object(&id).unwrap();
assert_eq!(retrieved, Some(obj));
}
#[test]
fn test_object_dedup() {
let store = test_store();
let obj = Object::string("dedup");
let id1 = store.put_object(&obj).unwrap();
let id2 = store.put_object(&obj).unwrap();
assert_eq!(id1, id2);
}
#[test]
fn test_commit_roundtrip() {
let store = test_store();
let commit = CommitBuilder::new(
ObjectId::hash(b"state"),
"agent/test",
Authority::simple("test"),
Intent::new(IntentCategory::Checkpoint, "test commit"),
)
.reasoning("testing sqlite backend")
.confidence(0.9)
.build();
store.put_commit(&commit).unwrap();
let retrieved = store.get_commit(&commit.id).unwrap().unwrap();
assert_eq!(retrieved.agent_id, "agent/test");
assert_eq!(
retrieved.reasoning,
Some("testing sqlite backend".to_string())
);
assert_eq!(retrieved.confidence, Some(0.9));
}
#[test]
fn test_ref_operations() {
let store = test_store();
let target = ObjectId::hash(b"commit-1");
let new_target = ObjectId::hash(b"commit-2");
let ns = Namespace::default_ns();
store.set_ref(&ns, "main", target).unwrap();
assert_eq!(store.get_ref(&ns, "main").unwrap(), Some(target));
assert!(store.cas_ref(&ns, "main", target, new_target).unwrap());
assert_eq!(store.get_ref(&ns, "main").unwrap(), Some(new_target));
let stale = ObjectId::hash(b"stale");
assert!(!store.cas_ref(&ns, "main", stale, target).unwrap());
}
#[test]
fn test_list_refs() {
let store = test_store();
let ns = Namespace::default_ns();
store
.set_ref(&ns, "agents/a", ObjectId::hash(b"a"))
.unwrap();
store
.set_ref(&ns, "agents/b", ObjectId::hash(b"b"))
.unwrap();
store.set_ref(&ns, "main", ObjectId::hash(b"m")).unwrap();
let agents = store.list_refs(&ns, "agents/").unwrap();
assert_eq!(agents.len(), 2);
let all = store.list_refs(&ns, "").unwrap();
assert_eq!(all.len(), 3);
}
#[test]
fn test_batch_put_objects() {
let store = test_store();
let objs = vec![
Object::string("one"),
Object::string("two"),
Object::string("three"),
];
let ids = store.batch_put_objects(&objs).unwrap();
assert_eq!(ids.len(), 3);
for id in ids.iter() {
assert!(store.has_object(id).unwrap());
}
}
#[test]
fn test_commit_chain() {
let store = test_store();
let commit1 = CommitBuilder::new(
ObjectId::hash(b"state-1"),
"agent/test",
Authority::simple("test"),
Intent::new(IntentCategory::Checkpoint, "first"),
)
.build();
store.put_commit(&commit1).unwrap();
let commit2 = CommitBuilder::new(
ObjectId::hash(b"state-2"),
"agent/test",
Authority::simple("test"),
Intent::new(IntentCategory::Refine, "second"),
)
.parent(commit1.id)
.build();
store.put_commit(&commit2).unwrap();
let commit3 = CommitBuilder::new(
ObjectId::hash(b"state-3"),
"agent/test",
Authority::simple("test"),
Intent::new(IntentCategory::Refine, "third"),
)
.parent(commit2.id)
.build();
store.put_commit(&commit3).unwrap();
let log = store.list_commits(&commit3.id, 10).unwrap();
assert_eq!(log.len(), 3);
assert_eq!(log[0].intent.description, "third");
assert_eq!(log[1].intent.description, "second");
assert_eq!(log[2].intent.description, "first");
}
#[test]
fn test_full_workflow_sqlite_storage_traits() {
let store = test_store();
let obj1 = Object::string("cluster-name");
let id1 = store.put_object(&obj1).unwrap();
let commit = CommitBuilder::new(
id1,
"agent/test",
Authority::simple("test"),
Intent::new(IntentCategory::Checkpoint, "full workflow test"),
)
.build();
store.put_commit(&commit).unwrap();
let ns = Namespace::default_ns();
store.set_ref(&ns, "main", commit.id).unwrap();
let ref_target = store.get_ref(&ns, "main").unwrap().unwrap();
assert_eq!(ref_target, commit.id);
let retrieved_commit = store.get_commit(&ref_target).unwrap().unwrap();
assert_eq!(retrieved_commit.state_root, id1);
let retrieved_obj = store.get_object(&id1).unwrap().unwrap();
assert_eq!(retrieved_obj, obj1);
}
use agentstategraph_reminders::{
Reminder, ReminderFilter, ReminderStore,
types::{CreateReminder, Priority, ReminderRef, ReminderStatus, Schedule},
};
use chrono::Duration;
fn future(secs: i64) -> chrono::DateTime<chrono::Utc> {
chrono::Utc::now() + Duration::seconds(secs)
}
fn past_ts(secs: i64) -> chrono::DateTime<chrono::Utc> {
chrono::Utc::now() - Duration::seconds(secs)
}
fn make_reminder(title: &str, secs_from_now: i64) -> Reminder {
CreateReminder::new(title, "do something", future(secs_from_now), "agent/test")
.into_reminder()
}
#[test]
fn reminder_save_and_get_roundtrip() {
let store = test_store();
let r = make_reminder("check server", 600);
store.save(&r).unwrap();
let got = store.get(&r.id).unwrap().unwrap();
assert_eq!(got.id, r.id);
assert_eq!(got.title, "check server");
assert_eq!(got.status, ReminderStatus::Pending);
assert!(got.autonomous);
}
#[test]
fn reminder_get_missing_returns_none() {
let store = test_store();
let result = store.get("nonexistent").unwrap();
assert!(result.is_none());
}
#[test]
fn reminder_save_duplicate_id_fails() {
let store = test_store();
let r = make_reminder("dup", 60);
store.save(&r).unwrap();
let err = store.save(&r).unwrap_err();
assert!(err.to_string().contains("insert reminder"));
}
#[test]
fn reminder_update_roundtrip() {
let store = test_store();
let mut r = make_reminder("update me", 300);
store.save(&r).unwrap();
r.status = ReminderStatus::Due;
r.title = "updated title".to_string();
store.update(&r).unwrap();
let got = store.get(&r.id).unwrap().unwrap();
assert_eq!(got.status, ReminderStatus::Due);
assert_eq!(got.title, "updated title");
}
#[test]
fn reminder_update_missing_returns_not_found() {
let store = test_store();
let r = make_reminder("ghost", 60);
let err = store.update(&r).unwrap_err();
assert!(matches!(
err,
agentstategraph_reminders::ReminderError::NotFound(_)
));
}
#[test]
fn reminder_delete_existing_returns_true() {
let store = test_store();
let r = make_reminder("delete me", 60);
store.save(&r).unwrap();
assert!(store.delete(&r.id).unwrap());
assert!(store.get(&r.id).unwrap().is_none());
}
#[test]
fn reminder_delete_missing_returns_false() {
let store = test_store();
assert!(!store.delete("ghost").unwrap());
}
#[test]
fn reminder_list_empty_filter_returns_all() {
let store = test_store();
let r1 = make_reminder("a", 100);
let r2 = make_reminder("b", 200);
store.save(&r1).unwrap();
store.save(&r2).unwrap();
let all = store.list(&ReminderFilter::default()).unwrap();
assert_eq!(all.len(), 2);
}
#[test]
fn reminder_list_filter_by_status() {
let store = test_store();
let r1 = make_reminder("pending", 100);
let mut r2 = make_reminder("due", 50);
r2.status = ReminderStatus::Due;
store.save(&r1).unwrap();
store.save(&r2).unwrap();
let filter = ReminderFilter {
status: Some(ReminderStatus::Due),
..Default::default()
};
let results = store.list(&filter).unwrap();
assert_eq!(results.len(), 1);
assert_eq!(results[0].title, "due");
}
#[test]
fn reminder_list_filter_by_priority_at_most() {
let store = test_store();
let critical = CreateReminder::new("c", "i", future(100), "a")
.with_priority(Priority::Critical)
.into_reminder();
let low = CreateReminder::new("l", "i", future(200), "a")
.with_priority(Priority::Low)
.into_reminder();
store.save(&critical).unwrap();
store.save(&low).unwrap();
let filter = ReminderFilter {
priority_at_most: Some(Priority::High),
..Default::default()
};
let results = store.list(&filter).unwrap();
assert_eq!(results.len(), 1);
assert_eq!(results[0].title, "c");
}
#[test]
fn reminder_list_filter_by_created_by() {
let store = test_store();
let r1 = CreateReminder::new("r1", "i", future(60), "agent/alice").into_reminder();
let r2 = CreateReminder::new("r2", "i", future(60), "agent/bob").into_reminder();
store.save(&r1).unwrap();
store.save(&r2).unwrap();
let filter = ReminderFilter {
created_by: Some("agent/alice".into()),
..Default::default()
};
let results = store.list(&filter).unwrap();
assert_eq!(results.len(), 1);
assert_eq!(results[0].title, "r1");
}
#[test]
fn reminder_list_filter_by_due_before() {
let store = test_store();
let soon = CreateReminder::new("soon", "i", future(60), "a").into_reminder();
let later = CreateReminder::new("later", "i", future(7200), "a").into_reminder();
store.save(&soon).unwrap();
store.save(&later).unwrap();
let filter = ReminderFilter {
due_before: Some(future(600)),
..Default::default()
};
let results = store.list(&filter).unwrap();
assert_eq!(results.len(), 1);
assert_eq!(results[0].title, "soon");
}
#[test]
fn reminder_list_filter_by_ref_id() {
let store = test_store();
let mut with_ref = make_reminder("with-ref", 60);
with_ref.refs = vec![ReminderRef::branch("main", "main branch")];
let without = make_reminder("without-ref", 60);
store.save(&with_ref).unwrap();
store.save(&without).unwrap();
let filter = ReminderFilter {
ref_id: Some("main".into()),
..Default::default()
};
let results = store.list(&filter).unwrap();
assert_eq!(results.len(), 1);
assert_eq!(results[0].title, "with-ref");
}
#[test]
fn reminder_list_filter_by_tags() {
let store = test_store();
let mut tagged = make_reminder("tagged", 60);
tagged.tags = vec!["cleanup".into(), "server".into()];
let untagged = make_reminder("untagged", 60);
store.save(&tagged).unwrap();
store.save(&untagged).unwrap();
let filter = ReminderFilter {
tags: vec!["cleanup".into()],
..Default::default()
};
let results = store.list(&filter).unwrap();
assert_eq!(results.len(), 1);
assert_eq!(results[0].title, "tagged");
}
#[test]
fn reminder_list_ordered_by_priority_then_due() {
let store = test_store();
let medium_late = CreateReminder::new("medium-late", "i", future(200), "a")
.with_priority(Priority::Medium)
.into_reminder();
let high_early = CreateReminder::new("high-early", "i", future(100), "a")
.with_priority(Priority::High)
.into_reminder();
let high_later = CreateReminder::new("high-later", "i", future(300), "a")
.with_priority(Priority::High)
.into_reminder();
store.save(&medium_late).unwrap();
store.save(&high_early).unwrap();
store.save(&high_later).unwrap();
let all = store.list(&ReminderFilter::default()).unwrap();
assert_eq!(all[0].title, "high-early");
assert_eq!(all[1].title, "high-later");
assert_eq!(all[2].title, "medium-late");
}
#[test]
fn reminder_persists_schedule_and_refs() {
let store = test_store();
let mut r = CreateReminder::new("scheduled", "i", future(60), "a")
.with_schedule(Schedule::Interval {
every_seconds: 3600,
})
.with_refs(vec![ReminderRef::plan("plan-123", "My plan")])
.into_reminder();
r.autonomous = false;
store.save(&r).unwrap();
let got = store.get(&r.id).unwrap().unwrap();
assert!(!got.autonomous);
assert!(matches!(
got.schedule,
Some(Schedule::Interval {
every_seconds: 3600
})
));
assert_eq!(got.refs.len(), 1);
assert_eq!(got.refs[0].id, "plan-123");
assert_eq!(got.refs[0].label.as_deref(), Some("My plan"));
}
#[test]
fn reminder_persists_snoozed_until() {
let store = test_store();
let mut r = make_reminder("snooze me", 60);
let snooze_time = future(3600);
r.status = ReminderStatus::Snoozed;
r.snoozed_until = Some(snooze_time);
store.save(&r).unwrap();
let got = store.get(&r.id).unwrap().unwrap();
assert_eq!(got.status, ReminderStatus::Snoozed);
assert!(got.snoozed_until.is_some());
let diff = (got.snoozed_until.unwrap() - snooze_time)
.num_seconds()
.abs();
assert!(diff < 2, "snoozed_until timestamp drifted by {diff}s");
}
#[test]
fn reminder_all_statuses_roundtrip() {
let store = test_store();
let statuses = [
ReminderStatus::Pending,
ReminderStatus::Due,
ReminderStatus::AwaitingPermission,
ReminderStatus::InProgress,
ReminderStatus::Completed,
ReminderStatus::Snoozed,
ReminderStatus::Cancelled,
];
for status in statuses {
let mut r = make_reminder(&format!("{status:?}"), 60);
r.status = status;
store.save(&r).unwrap();
let got = store.get(&r.id).unwrap().unwrap();
assert_eq!(got.status, status, "status roundtrip failed for {status:?}");
}
}
#[test]
fn reminder_all_priorities_roundtrip() {
let store = test_store();
let priorities = [
Priority::Critical,
Priority::High,
Priority::Medium,
Priority::Low,
Priority::Minimal,
];
for p in priorities {
let r = CreateReminder::new(&format!("{p:?}"), "i", future(60), "a")
.with_priority(p)
.into_reminder();
store.save(&r).unwrap();
let got = store.get(&r.id).unwrap().unwrap();
assert_eq!(got.priority, p, "priority roundtrip failed for {p:?}");
}
}
fn temp_db_path(tag: &str) -> std::path::PathBuf {
let nanos = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos();
std::env::temp_dir().join(format!("asg-{tag}-{}-{nanos}.db", std::process::id()))
}
fn remove_db(path: &std::path::Path) {
for suffix in ["", "-wal", "-shm"] {
let _ = std::fs::remove_file(format!("{}{suffix}", path.display()));
}
}
#[test]
fn gc_write_lock_excludes_other_writers_but_not_readers() {
let path = temp_db_path("gc-lock");
let store = SqliteStorage::open(&path).unwrap();
store.put_object(&Object::string("seed")).unwrap();
let other = rusqlite::Connection::open(&path).unwrap();
other.busy_timeout(std::time::Duration::ZERO).unwrap();
store.history_gc_lock_writers().unwrap();
match other.execute_batch("BEGIN IMMEDIATE") {
Err(rusqlite::Error::SqliteFailure(e, _)) => {
assert_eq!(e.code, rusqlite::ErrorCode::DatabaseBusy)
}
other => panic!("a second writer got in while the GC lock was held: {other:?}"),
}
let objects: i64 = other
.query_row("SELECT COUNT(*) FROM objects", [], |r| r.get(0))
.unwrap();
assert_eq!(objects, 1, "readers are not blocked");
store.history_gc_unlock_writers(true).unwrap();
other
.execute_batch("BEGIN IMMEDIATE; COMMIT;")
.expect("released lock admits writers again");
store.history_gc_unlock_writers(true).unwrap();
drop(other);
drop(store);
remove_db(&path);
}
#[test]
fn unpin_legacy_milestones_clears_only_unrequested_pins() {
let store = test_store();
let routine = CommitBuilder::new(
ObjectId::hash(b"routine-state"),
"asd",
Authority::simple("asd"),
Intent::new(IntentCategory::Checkpoint, "asd index: 9 symbols"),
)
.build();
let release = CommitBuilder::new(
ObjectId::hash(b"release-state"),
"alice",
Authority::simple("alice"),
Intent::new(IntentCategory::Checkpoint, "v1.0 release")
.with_tags(vec![TAG_PIN_STATE.to_string()]),
)
.build();
store.put_commit(&routine).unwrap();
store.put_commit(&release).unwrap();
store.history_extract_batch(100).unwrap();
{
let conn = store.lock_conn().unwrap();
conn.execute(
"UPDATE asg_history_milestone SET state_root = ?1 WHERE commit_id = ?2",
params![
routine.state_root.as_bytes().as_slice(),
routine.id.as_bytes().as_slice()
],
)
.unwrap();
}
let before = store.history_retained_state_roots().unwrap();
assert!(before.contains(&routine.state_root));
assert!(before.contains(&release.state_root));
assert_eq!(store.history_unpin_legacy_milestones().unwrap(), 1);
assert_eq!(
store.history_retained_state_roots().unwrap(),
vec![release.state_root],
"only the requested pin survives"
);
assert_eq!(
store.history_unpin_legacy_milestones().unwrap(),
0,
"one-time: nothing left to unpin"
);
assert_eq!(
store.history_milestones(10).unwrap().len(),
2,
"unpinning drops the snapshot hook, not the milestone"
);
}
}