Skip to content

Solution for long term memory for agent coding CLIs and to facilitate handoff between different agent vendors

Rust

Merge pull request #1834 from everton-dgn/feat/managed-project-id-recovery

AkitaOnRails3beb78ea1c2d
diff --cc crates/ai-memory-store/migrations/V96__managed_run_scope_by_id.sql
index 00000000,9f164ac8..9f164ac8
mode 000000,100644..100644
--- a/crates/ai-memory-store/migrations/V96__managed_run_scope_by_id.sql
+++ b/crates/ai-memory-store/migrations/V96__managed_run_scope_by_id.sql
diff --cc crates/ai-memory-store/src/api_credentials.rs
index 8a1944ff,59802667..21eb7fc0
--- a/crates/ai-memory-store/src/api_credentials.rs
+++ b/crates/ai-memory-store/src/api_credentials.rs
@@@ -470,7 -470,7 +470,7 @@@ mod tests
|row| row.get(0),
)
.unwrap();
- assert_eq!(version, 95, "update the pin when adding a migration");
- assert_eq!(version, 91, "update the pin when adding a migration");
++ assert_eq!(version, 96, "update the pin when adding a migration");
let cols: i64 = conn
.query_row(
"SELECT COUNT(*) FROM pragma_table_info('users') \
diff --cc crates/ai-memory-store/src/migrations.rs
index baa153d0,a470a1fb..0bd8decb
--- a/crates/ai-memory-store/src/migrations.rs
+++ b/crates/ai-memory-store/src/migrations.rs
@@@ -164,158 -164,67 +164,219 @@@ mod tests
};
use rusqlite::{Connection, params};
+ #[test]
+ fn v92_preserves_old_response_rows_and_cascades_context() {
+ let mut conn = Connection::open_in_memory().unwrap();
+ conn.pragma_update(None, "foreign_keys", "OFF").unwrap();
+ run_to(&mut conn, 91).unwrap();
+ conn.execute_batch("INSERT INTO workspaces(id,name,created_at) VALUES(zeroblob(16),'usage',1);
+ INSERT INTO projects(id,workspace_id,name,created_at) VALUES(zeroblob(16),zeroblob(16),'usage',1);
+ INSERT INTO sessions(id,workspace_id,project_id,agent_kind,started_at) VALUES(zeroblob(16),zeroblob(16),zeroblob(16),'codex',1);
+ INSERT INTO token_calls(session_id,call_id,input_tokens,output_tokens,cache_write_tokens,cache_read_tokens,observed_at) VALUES(zeroblob(16),'old-response',70,7,0,0,123);").unwrap();
+ run(&mut conn).unwrap();
+ run(&mut conn).unwrap();
+ conn.pragma_update(None, "foreign_keys", "ON").unwrap();
+ let preserved:(u64,u64,i64,Option<String>,Option<String>,Option<i64>)=conn.query_row("SELECT input_tokens,output_tokens,observed_at,turn_id,native_response_id,response_at FROM token_calls",[],|r|Ok((r.get(0)?,r.get(1)?,r.get(2)?,r.get(3)?,r.get(4)?,r.get(5)?))).unwrap();
+ assert_eq!(preserved, (70, 7, 123, None, None, None));
+ conn.execute_batch("INSERT INTO token_call_tools(session_id,call_id,tool_id,tool_name,relation) VALUES(zeroblob(16),'old-response','tool-1','Read','requested');
+ DELETE FROM token_calls WHERE call_id='old-response';").unwrap();
+ assert_eq!(
+ conn.query_row("SELECT COUNT(*) FROM token_call_tools", [], |r| r
+ .get::<_, u64>(0))
+ .unwrap(),
+ 0
+ );
+ }
+
+ #[test]
+ fn v90_normalizes_codex_cache_once_and_preserves_claude() {
+ let mut conn = Connection::open_in_memory().unwrap();
+ conn.pragma_update(None, "foreign_keys", "OFF").unwrap();
+ run_to(&mut conn, 89).unwrap();
+ conn.execute_batch("INSERT INTO workspaces(id,name,created_at) VALUES(zeroblob(16),'usage',1);
+ INSERT INTO projects(id,workspace_id,name,created_at) VALUES(zeroblob(16),zeroblob(16),'usage',1);
+ INSERT INTO sessions(id,workspace_id,project_id,agent_kind,started_at) VALUES(zeroblob(16),zeroblob(16),zeroblob(16),'codex',1);
+ INSERT INTO sessions(id,workspace_id,project_id,agent_kind,started_at) VALUES(x'00000000000000000000000000000001',zeroblob(16),zeroblob(16),'claude-code',1);
+ INSERT INTO session_usage(session_id,input_tokens,cache_read_tokens,updated_at) SELECT id,1000,800,1 FROM sessions;").unwrap();
+ run(&mut conn).unwrap();
+ run(&mut conn).unwrap();
+ let codex: u64 = conn
+ .query_row(
+ "SELECT input_tokens FROM session_usage WHERE session_id=zeroblob(16)",
+ [],
+ |r| r.get(0),
+ )
+ .unwrap();
+ let claude:u64=conn.query_row("SELECT input_tokens FROM session_usage WHERE session_id=x'00000000000000000000000000000001'",[],|r|r.get(0)).unwrap();
+ assert_eq!(codex, 200);
+ assert_eq!(claude, 1000);
+ }
+
+ /// V95 rebuilds `agent_messages` so a message can be held in `editing`.
+ /// Existing mail keeps its text, state, order and addressee, the three
+ /// indexes come back, and `editing` is the only value the constraint gained.
+ #[test]
+ fn v93_accepts_the_editing_state_and_keeps_existing_messages() {
+ let mut conn = Connection::open_in_memory().unwrap();
+ conn.pragma_update(None, "foreign_keys", "OFF").unwrap();
+ run_to(&mut conn, 92).unwrap();
+ conn.execute_batch(
+ "INSERT INTO workspaces(id,name,created_at) VALUES(zeroblob(16),'mail',1);
+ INSERT INTO projects(id,workspace_id,name,created_at) VALUES(zeroblob(16),zeroblob(16),'mail',1);
+ INSERT INTO agent_messages(id,from_workspace_id,from_project_id,from_agent,to_workspace_id,to_project_id,subject,body,state,created_at,to_agent,from_owner_user)
+ VALUES(x'01000000000000000000000000000000',zeroblob(16),zeroblob(16),'other',zeroblob(16),zeroblob(16),'s','queued','pending',5,'codex','user:sender');
+ INSERT INTO agent_messages(id,from_workspace_id,from_project_id,from_agent,to_workspace_id,to_project_id,body,state,created_at,claimed_at,claimed_by_agent)
+ VALUES(x'02000000000000000000000000000000',zeroblob(16),zeroblob(16),'other',zeroblob(16),zeroblob(16),'done','claimed',6,7,'codex');",
+ )
+ .unwrap();
+ run(&mut conn).unwrap();
+ run(&mut conn).unwrap();
+ conn.pragma_update(None, "foreign_keys", "ON").unwrap();
+
+ let rows: Vec<(String, String, i64, Option<String>)> = conn
+ .prepare(
+ "SELECT state, body, created_at, to_agent FROM agent_messages ORDER BY created_at",
+ )
+ .unwrap()
+ .query_map([], |r| Ok((r.get(0)?, r.get(1)?, r.get(2)?, r.get(3)?)))
+ .unwrap()
+ .collect::<Result<_, _>>()
+ .unwrap();
+ assert_eq!(
+ rows,
+ vec![
+ (
+ "pending".to_owned(),
+ "queued".to_owned(),
+ 5,
+ Some("codex".to_owned())
+ ),
+ ("claimed".to_owned(), "done".to_owned(), 6, None),
+ ]
+ );
+ conn.execute(
+ "UPDATE agent_messages SET state='editing' WHERE body='queued'",
+ [],
+ )
+ .unwrap();
+ assert!(
+ conn.execute(
+ "UPDATE agent_messages SET state='held' WHERE body='queued'",
+ [],
+ )
+ .is_err(),
+ "the state constraint must still reject unknown values"
+ );
+ let indexes: i64 = conn
+ .query_row(
+ "SELECT COUNT(*) FROM sqlite_master WHERE type='index' AND tbl_name='agent_messages' \
+ AND name IN ('idx_agent_messages_inbox','idx_agent_messages_outbox','idx_messages_agent_inbox')",
+ [],
+ |r| r.get(0),
+ )
+ .unwrap();
+ assert_eq!(indexes, 3);
+ let edited_at: i64 = conn
+ .query_row(
+ "SELECT COUNT(*) FROM pragma_table_info('agent_messages') WHERE name='edited_at'",
+ [],
+ |r| r.get(0),
+ )
+ .unwrap();
+ assert_eq!(edited_at, 1);
+ let provenance: (Option<String>, Option<String>) = conn
+ .query_row(
+ "SELECT from_owner_user, subject FROM agent_messages WHERE body='queued'",
+ [],
+ |r| Ok((r.get(0)?, r.get(1)?)),
+ )
+ .unwrap();
+ assert_eq!(
+ provenance,
+ (Some("user:sender".to_owned()), Some("s".to_owned())),
+ "the sender identity and subject survive the rebuild"
+ );
+ assert!(
+ conn.execute(
+ "UPDATE agent_messages SET from_session_id=zeroblob(16) WHERE body='queued'",
+ [],
+ )
+ .is_err(),
+ "the sender-session foreign key survives the rebuild"
+ );
+ conn.execute_batch("INSERT INTO sessions(id,workspace_id,project_id,agent_kind,started_at) VALUES(zeroblob(16),zeroblob(16),zeroblob(16),'codex',1);
+ UPDATE agent_messages SET from_session_id=zeroblob(16) WHERE body='queued';").unwrap();
+ let dangling: i64 = conn
+ .query_row(
+ "SELECT COUNT(*) FROM pragma_foreign_key_check('agent_messages')",
+ [],
+ |r| r.get(0),
+ )
+ .unwrap();
+ assert_eq!(dangling, 0);
+ }
+
+ #[test]
+ fn project_id_pinning_upgrade_preserves_runs_and_failed_prepare_rolls_back() {
+ let mut conn = Connection::open_in_memory().unwrap();
- run_to(&mut conn, 90).unwrap();
++ run_to(&mut conn, 95).unwrap();
+ conn.pragma_update(None, "foreign_keys", "ON").unwrap();
+ let ws = crate::ops::get_or_create_workspace(&mut conn, "default").unwrap();
+ let project = crate::ops::get_or_create_project(&mut conn, &ws, "project", None).unwrap();
+ let workstream = ai_memory_core::WorkstreamId::new();
+ let run_id = ai_memory_core::ManagedRunId::new();
+ conn.execute("INSERT INTO workstreams \
+ (id, workspace_id, project_id, repo_fingerprint, worktree_fingerprint, name, cwd, created_at, selected_at, updated_at) \
+ VALUES (?1, ?2, ?3, 'repo', 'tree', 'default', '/repo', 1, 1, 1)",
+ params![workstream.as_bytes(), ws.as_bytes(), project.as_bytes()]).unwrap();
+ conn.execute("INSERT INTO managed_runs \
+ (id, workstream_id, agent_kind, lease_owner, state, sync_after, sync_through, context_delivered, lease_expires_at, started_at) \
+ VALUES (?1, ?2, 'codex', 'host:1', 'active', 3, 7, 1, ?3, 1)",
+ params![run_id.as_bytes(), workstream.as_bytes(), jiff::Timestamp::now().as_microsecond() + 60_000_000]).unwrap();
+ run(&mut conn).unwrap();
+ let snapshot = |conn: &Connection| {
+ conn.query_row(
+ "SELECT state, sync_after, sync_through, context_delivered, scope_by_id FROM managed_runs WHERE id = ?1",
+ params![run_id.as_bytes()], |row| Ok((row.get::<_,String>(0)?, row.get::<_,i64>(1)?, row.get::<_,i64>(2)?, row.get::<_,bool>(3)?, row.get::<_,bool>(4)?))).unwrap()
+ };
+ assert_eq!(snapshot(&conn), ("active".into(), 3, 7, true, false));
+ conn.execute_batch("CREATE TRIGGER reject_new_run BEFORE INSERT ON managed_runs BEGIN SELECT RAISE(ABORT, 'injected failure'); END;").unwrap();
+ let input = crate::PrepareWorkstreamRun {
+ workspace_id: ws,
+ project_id: project,
+ scope_by_id: true,
+ repo_fingerprint: "repo".into(),
+ worktree_fingerprint: "tree".into(),
+ cwd: "/repo".into(),
+ agent: AgentKind::Codex,
+ automatic_harness: false,
+ available_agents: Vec::new(),
+ selection: crate::WorkstreamSelection::Named("default".into()),
+ lease_owner: "host:2".into(),
+ };
+ assert!(crate::workstream::prepare_run(&mut conn, &input, None, true).is_err());
+ assert_eq!(
+ snapshot(&conn),
+ ("active".into(), 3, 7, true, false),
+ "failed prepare must roll back forced expiry and preserve the legacy flag"
+ );
+ let count: i64 = conn
+ .query_row("SELECT COUNT(*) FROM managed_runs", [], |row| row.get(0))
+ .unwrap();
+ assert_eq!(count, 1);
+ conn.execute_batch("DROP TRIGGER reject_new_run;").unwrap();
+ let prepared = crate::workstream::prepare_run(&mut conn, &input, None, true).unwrap();
+ let pinned: bool = conn
+ .query_row(
+ "SELECT scope_by_id FROM managed_runs WHERE id = ?1",
+ params![prepared.run_id.as_bytes()],
+ |row| row.get(0),
+ )
+ .unwrap();
+ assert!(pinned);
+ assert_eq!(snapshot(&conn).0, "expired");
+ }
+
/// A store migrated by a newer build (an applied version above anything
/// this binary embeds) must fail to open with the actionable
/// `DataSchemaAhead` error, not refinery's raw "missing from the