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.sqlindex 00000000,9f164ac8..9f164ac8mode 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.sqldiff --cc crates/ai-memory-store/src/api_credentials.rsindex 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.rsindex 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