Solution for long term memory for agent coding CLIs and to facilitate handoff between different agent vendors
Rust
fix: scan all projects in auto-improve scheduler
AkitaOnRailse06643f1ecef
diff --git a/AGENTS.md b/AGENTS.mdindex 09626784..8dadbde9 100644--- a/AGENTS.md+++ b/AGENTS.md@@ -42,7 +42,7 @@ match the intent to the tool. They do not need to name the tool.| "save context for the next session" / wrapping up / ending this session | `memory_handoff_begin` (session-end only; do **not** use for status/briefing; single-use handoff; terse summary; put detail in `open_questions` + `next_steps` bullets; pass `workspace` + `project` together only for a named sibling workspace/project) || "discard that handoff" / "I created a handoff by mistake" | `memory_handoff_cancel` (requires exact `handoff_id` from `memory_handoff_begin`; marks it expired before the next session sees it) || "consolidate this session" / "compile what we learned" (also runs on PreCompact; at session end only if `AI_MEMORY_CONSOLIDATE_ON_SESSION_END` is set) | `memory_consolidate` |-| "what did we learn from this session?" / "what memory should we add?" / explicit wrap-up learning review | `memory_auto_improve` (manual learning review for a completed session; omit `session_id` for latest completed session; the server also schedules background review for newly completed sessions when configured) |+| "what did we learn from this session?" / "what memory should we add?" / explicit wrap-up learning review | `memory_auto_improve` (manual learning review for a completed session; omit `session_id` for latest completed session; the server also schedules background review for newly completed sessions in every project when configured) || "remember this permanently" / "save a note" / "add an annotation" / durable project knowledge | `memory_write_page` (write a wiki page; do **not** use handoff for permanent notes; put the title as a `# H1` on the first line of `body` and omit the `title` arg — ai-memory derives it from the H1) || "read the page about X" / "show me the full content of Y" / "open the page on Z" | `memory_read_page` (full body; pass a query to search or `path` for a direct lookup; pass `workspace` + `project` together only for a named sibling workspace/project) || "delete the page X" / "remove that note" | `memory_delete_page` (by exact `path`; idempotent; pass `workspace` + `project` together only for a named sibling workspace/project) |@@ -96,8 +96,8 @@ query specific error/subsystem terms before designing a fix.### Learning Review-The server schedules background auto-improvement for newly completed sessions-when an LLM provider is configured. `memory_auto_improve` is the manual version:+The server schedules background auto-improvement for newly completed sessions in+every project when an LLM provider is configured. `memory_auto_improve` is the manual version:use it when the user asks what durable lessons this session suggests, or atexplicit wrap-up when reviewing proposed memory would be useful. Scheduled andmanual runs apply or stage validated edits through the auto-improvement approvaldiff --git a/CHANGELOG.md b/CHANGELOG.mdindex 403b2de5..ab09f1ee 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0## [Unreleased]+### Fixed+- Auto-improvement scheduling now scans every known project each tick instead of+ only the server's startup/default project. Scheduler ticks remain+ non-overlapping; if reviewing all projects takes longer than the configured+ interval, the next tick is delayed until the current tick finishes.+## [1.0.11] - 2026-06-15### Addeddiff --git a/README.md b/README.mdindex 786a4c64..7ecda171 100644--- a/README.md+++ b/README.md@@ -130,14 +130,16 @@ priors are at the [bottom](#influences-and-prior-art).build on top.- **"What durable lesson did that session teach?"**When an LLM provider is configured, ai-memory runs a background- auto-improvement scheduler for newly completed sessions. It records proposed- wiki edits in the pending-writes audit trail, then approves them immediately- through the normal wiki write path by default. Scheduling and approval are- separate: set `[auto_improve.scheduler] enabled = false` to stop automatic- review, or set `[auto_improve] require_approval = true` to keep both scheduled- and manual proposals pending for human review. `ai-memory auto-improve- --session-id <uuid>` and MCP `memory_auto_improve` remain available for manual- catch-up or targeted reruns.+ auto-improvement scheduler for newly completed sessions in every project. It+ records proposed wiki edits in the pending-writes audit trail, then approves+ them immediately through the normal wiki write path by default. Scheduler ticks+ are non-overlapping: if reviewing all projects takes longer than the interval,+ the next tick is delayed until the current one finishes. Scheduling and+ approval are separate: set `[auto_improve.scheduler] enabled = false` to stop+ automatic review, or set `[auto_improve] require_approval = true` to keep both+ scheduled and manual proposals pending for human review. `ai-memory+ auto-improve --session-id <uuid>` and MCP `memory_auto_improve` remain+ available for manual catch-up or targeted reruns.Existing installs do not need per-project migration. The scheduler initializesa per-project first-run watermark so historical sessions are not revieweddiff --git a/crates/ai-memory-cli/src/commands/serve.rs b/crates/ai-memory-cli/src/commands/serve.rsindex 37577f6f..b13720f5 100644--- a/crates/ai-memory-cli/src/commands/serve.rs+++ b/crates/ai-memory-cli/src/commands/serve.rs@@ -193,7 +193,8 @@ pub async fn run(config: &Config, args: ServeArgs) -> Result<()> {ws,proj,config.decay,- );+ )+ .await;match args.transport {TransportKind::Stdio => {@@ -431,7 +432,7 @@ pub async fn run(config: &Config, args: ServeArgs) -> Result<()> {}#[allow(clippy::too_many_arguments)]-fn start_maintenance_scheduler(+async fn start_maintenance_scheduler(settings: MaintenanceSettings,auto_improve: AutoImproveSettings,reader: ReaderPool,@@ -541,101 +542,40 @@ fn start_maintenance_scheduler(let reader = reader.clone();let writer = writer.clone();let wiki = wiki.clone();+ match initialize_auto_improve_scheduler_scopes(&reader, &writer).await {+ Ok((scopes, errors)) => info!(+ scopes,+ errors, "auto-improve scheduler startup scope initialization completed"+ ),+ Err(e) => tracing::warn!(+ error = %e,+ "auto-improve scheduler startup scope initialization failed"+ ),+ }tasks.push(tokio::spawn(async move {let interval = std::time::Duration::from_secs(scheduler.interval_secs);- if let Err(e) = writer- .ensure_auto_improve_scheduler_state(workspace_id, project_id)- .await- {- tracing::warn!(error = %e, "scheduled auto-improve state init failed");- }+ // Sleep after each complete tick instead of driving work from a+ // fixed-rate interval. If reviewing all projects takes longer than+ // `interval`, the next tick is delayed rather than overlapping the+ // still-running one.loop {tokio::time::sleep(interval).await;- if let Err(e) = writer- .ensure_auto_improve_scheduler_state(workspace_id, project_id)- .await- {- tracing::warn!(error = %e, "scheduled auto-improve state init failed");- continue;- }- let candidates = match reader- .auto_improve_candidate_sessions(- workspace_id,- project_id,- scheduler.min_session_age_secs,- scheduler.max_sessions_per_tick,- )+ let started = std::time::Instant::now();+ match run_auto_improve_scheduler_tick(&reader, &writer, &wiki, &llm, &auto_improve).await{- Ok(candidates) => candidates,+ Ok(outcome) => info!(+ scopes = outcome.scopes,+ scopes_with_candidates = outcome.scopes_with_candidates,+ reviewed = outcome.reviewed,+ errors = outcome.errors,+ elapsed_ms = started.elapsed().as_millis(),+ "scheduled auto-improve tick completed"+ ),Err(e) => {- tracing::warn!(error = %e, "scheduled auto-improve candidate query failed");- continue;+ tracing::warn!(error = %e, "scheduled auto-improve tick failed")}};- if candidates.is_empty() {- tracing::debug!("scheduled auto-improve found no eligible sessions");- continue;- }- let mut reviewed = 0usize;- let ctx = ScheduledAutoImproveContext {- reader: &reader,- writer: &writer,- wiki: &wiki,- llm: &llm,- workspace_id,- project_id,- settings: &auto_improve,- };- for candidate in candidates {- let claimed = match ctx- .writer- .claim_auto_improve_scheduler_session(- ctx.workspace_id,- ctx.project_id,- candidate.session_id,- candidate.ended_at,- )- .await- {- Ok(claimed) => claimed,- Err(e) => {- tracing::warn!(- session_id = %candidate.session_id,- error = %e,- "scheduled auto-improve claim failed"- );- continue;- }- };- if !claimed {- tracing::debug!(- session_id = %candidate.session_id,- "scheduled auto-improve candidate already claimed or reviewed"- );- continue;- }- match run_scheduled_auto_improve(&ctx, candidate.session_id).await {- Ok(outcome) => {- reviewed += 1;- info!(- session_id = %candidate.session_id,- run_id = %outcome.run_id,- proposals = outcome.proposals,- approved = outcome.approved,- pending = outcome.pending,- conflicts = outcome.conflicts,- "scheduled auto-improve completed"- );- }- Err(e) => tracing::warn!(- session_id = %candidate.session_id,- error = %e,- "scheduled auto-improve failed"- ),- }- }- info!(reviewed, "scheduled auto-improve tick completed");}}));} else {@@ -650,6 +590,30 @@ fn start_maintenance_scheduler(tasks}+async fn initialize_auto_improve_scheduler_scopes(+ reader: &ReaderPool,+ writer: &WriterHandle,+) -> Result<(usize, usize)> {+ let scopes = reader.list_all_scopes().await?;+ let total = scopes.len();+ let mut errors = 0usize;+ for scope in scopes {+ if let Err(e) = writer+ .ensure_auto_improve_scheduler_state(scope.workspace_id, scope.project_id)+ .await+ {+ errors += 1;+ tracing::warn!(+ workspace = %scope.workspace_name,+ project = %scope.project_name,+ error = %e,+ "auto-improve scheduler startup state init failed"+ );+ }+ }+ Ok((total, errors))+}+async fn run_embedding_backfill(reader: &ReaderPool,writer: &WriterHandle,@@ -739,6 +703,14 @@ struct ScheduledAutoImproveOutcome {conflicts: usize,}+#[derive(Debug, Default)]+struct ScheduledAutoImproveTickOutcome {+ scopes: usize,+ scopes_with_candidates: usize,+ reviewed: usize,+ errors: usize,+}+struct ScheduledAutoImproveContext<'a> {reader: &'a ReaderPool,writer: &'a WriterHandle,@@ -749,6 +721,134 @@ struct ScheduledAutoImproveContext<'a> {settings: &'a AutoImproveSettings,}+async fn run_auto_improve_scheduler_tick(+ reader: &ReaderPool,+ writer: &WriterHandle,+ wiki: &Wiki,+ llm: &Arc<dyn LlmProvider>,+ settings: &AutoImproveSettings,+) -> Result<ScheduledAutoImproveTickOutcome> {+ let scopes = reader.list_all_scopes().await?;+ let mut outcome = ScheduledAutoImproveTickOutcome {+ scopes: scopes.len(),+ ..ScheduledAutoImproveTickOutcome::default()+ };++ for scope in scopes {+ if let Err(e) = writer+ .ensure_auto_improve_scheduler_state(scope.workspace_id, scope.project_id)+ .await+ {+ outcome.errors += 1;+ tracing::warn!(+ workspace = %scope.workspace_name,+ project = %scope.project_name,+ error = %e,+ "scheduled auto-improve state init failed"+ );+ continue;+ }++ let candidates = match reader+ .auto_improve_candidate_sessions(+ scope.workspace_id,+ scope.project_id,+ settings.scheduler.min_session_age_secs,+ settings.scheduler.max_sessions_per_tick,+ )+ .await+ {+ Ok(candidates) => candidates,+ Err(e) => {+ outcome.errors += 1;+ tracing::warn!(+ workspace = %scope.workspace_name,+ project = %scope.project_name,+ error = %e,+ "scheduled auto-improve candidate query failed"+ );+ continue;+ }+ };+ if candidates.is_empty() {+ continue;+ }++ outcome.scopes_with_candidates += 1;+ let ctx = ScheduledAutoImproveContext {+ reader,+ writer,+ wiki,+ llm,+ workspace_id: scope.workspace_id,+ project_id: scope.project_id,+ settings,+ };+ for candidate in candidates {+ let claimed = match ctx+ .writer+ .claim_auto_improve_scheduler_session(+ ctx.workspace_id,+ ctx.project_id,+ candidate.session_id,+ candidate.ended_at,+ )+ .await+ {+ Ok(claimed) => claimed,+ Err(e) => {+ outcome.errors += 1;+ tracing::warn!(+ workspace = %scope.workspace_name,+ project = %scope.project_name,+ session_id = %candidate.session_id,+ error = %e,+ "scheduled auto-improve claim failed"+ );+ continue;+ }+ };+ if !claimed {+ tracing::debug!(+ workspace = %scope.workspace_name,+ project = %scope.project_name,+ session_id = %candidate.session_id,+ "scheduled auto-improve candidate already claimed or reviewed"+ );+ continue;+ }+ match run_scheduled_auto_improve(&ctx, candidate.session_id).await {+ Ok(run) => {+ outcome.reviewed += 1;+ info!(+ workspace = %scope.workspace_name,+ project = %scope.project_name,+ session_id = %candidate.session_id,+ run_id = %run.run_id,+ proposals = run.proposals,+ approved = run.approved,+ pending = run.pending,+ conflicts = run.conflicts,+ "scheduled auto-improve completed"+ );+ }+ Err(e) => {+ outcome.errors += 1;+ tracing::warn!(+ workspace = %scope.workspace_name,+ project = %scope.project_name,+ session_id = %candidate.session_id,+ error = %e,+ "scheduled auto-improve failed"+ );+ }+ }+ }+ }++ Ok(outcome)+}+async fn run_scheduled_auto_improve(ctx: &ScheduledAutoImproveContext<'_>,session_id: SessionId,@@ -1625,13 +1725,50 @@ fn host_without_port(host: &str) -> &str {#[cfg(test)]mod tests {use super::*;- use ai_memory_core::{PagePath, Tier};- use ai_memory_llm::SyntheticEmbedder;+ use ai_memory_core::{AgentKind, NewSession, PagePath, Tier};+ use ai_memory_llm::{ChatRequest, ChatResponse, LlmResult, SyntheticEmbedder};use ai_memory_wiki::WritePageRequest;use axum::http::Request;+ use std::future::Future;+ use std::pin::Pin;use tempfile::TempDir;use tower::ServiceExt;+ struct PanicLlm;++ impl LlmProvider for PanicLlm {+ fn name(&self) -> &'static str {+ "panic"+ }++ fn model(&self) -> &str {+ "panic"+ }++ fn complete<'life0, 'async_trait>(+ &'life0 self,+ _request: ChatRequest,+ ) -> Pin<Box<dyn Future<Output = LlmResult<ChatResponse>> + Send + 'async_trait>>+ where+ 'life0: 'async_trait,+ Self: 'async_trait,+ {+ Box::pin(async move { panic!("preflight-skipped scheduler test must not call LLM") })+ }++ fn complete_structured_raw<'life0, 'async_trait>(+ &'life0 self,+ _request: ChatRequest,+ _schema: serde_json::Value,+ ) -> Pin<Box<dyn Future<Output = LlmResult<serde_json::Value>> + Send + 'async_trait>>+ where+ 'life0: 'async_trait,+ Self: 'async_trait,+ {+ Box::pin(async move { panic!("preflight-skipped scheduler test must not call LLM") })+ }+ }+#[test]fn host_allowed_accepts_host_with_port() {let allowed = vec!["127.0.0.1".to_string(), "localhost".to_string()];@@ -2301,6 +2438,100 @@ mod tests {);}+ #[tokio::test]+ async fn auto_improve_scheduler_startup_init_preserves_first_interval_sessions() {+ let tmp = TempDir::new().unwrap();+ let store = Store::open(tmp.path()).unwrap();+ let wiki = Wiki::new(tmp.path(), store.writer.clone()).unwrap();+ let ws = store+ .writer+ .get_or_create_workspace("default")+ .await+ .unwrap();+ let first_project = store+ .writer+ .get_or_create_project(ws, "first", None)+ .await+ .unwrap();+ let second_project = store+ .writer+ .get_or_create_project(ws, "second", None)+ .await+ .unwrap();++ for project_id in [first_project, second_project] {+ let before_startup_init = SessionId::new();+ store+ .writer+ .begin_session(NewSession {+ id: before_startup_init,+ workspace_id: ws,+ project_id,+ agent_kind: AgentKind::OpenCode,+ cwd: None,+ })+ .await+ .unwrap();+ store+ .writer+ .end_session(before_startup_init, None)+ .await+ .unwrap();+ }++ assert_eq!(+ initialize_auto_improve_scheduler_scopes(&store.reader, &store.writer)+ .await+ .unwrap(),+ (2, 0)+ );++ tokio::time::sleep(std::time::Duration::from_millis(1)).await;+ let mut first_interval_sessions = Vec::new();+ for project_id in [first_project, second_project] {+ let session_id = SessionId::new();+ store+ .writer+ .begin_session(NewSession {+ id: session_id,+ workspace_id: ws,+ project_id,+ agent_kind: AgentKind::OpenCode,+ cwd: None,+ })+ .await+ .unwrap();+ store.writer.end_session(session_id, None).await.unwrap();+ first_interval_sessions.push((project_id, session_id));+ }++ let mut settings = AutoImproveSettings::default();+ settings.scheduler.min_session_age_secs = 0;+ settings.scheduler.max_sessions_per_tick = 10;+ let llm: Arc<dyn LlmProvider> = Arc::new(PanicLlm);+ let outcome =+ run_auto_improve_scheduler_tick(&store.reader, &store.writer, &wiki, &llm, &settings)+ .await+ .unwrap();++ assert_eq!(outcome.scopes, 2);+ assert_eq!(outcome.scopes_with_candidates, 2);+ assert_eq!(outcome.reviewed, 4);+ assert_eq!(outcome.errors, 0);++ for (project_id, session_id) in first_interval_sessions {+ let candidates = store+ .reader+ .auto_improve_candidate_sessions(ws, project_id, 0, 10)+ .await+ .unwrap();+ assert!(+ candidates.iter().all(|c| c.session_id != session_id),+ "first-interval session should have been reviewed or claimed"+ );+ }+ }+// ── Part B: CORS validation tests ──────────────────────────────────────#[test]diff --git a/crates/ai-memory-cli/src/config.rs b/crates/ai-memory-cli/src/config.rsindex 3cbbf4a9..93da4fe4 100644--- a/crates/ai-memory-cli/src/config.rs+++ b/crates/ai-memory-cli/src/config.rs@@ -403,7 +403,7 @@ pub struct AutoImproveSchedulerSettings {pub enabled: bool,/// Scheduler cadence. `0` disables the scheduler while keeping manual runs.pub interval_secs: u64,- /// Maximum sessions reviewed per scheduler tick. `0` disables the scheduler.+ /// Maximum sessions reviewed per project in one scheduler tick. `0` disables the scheduler.pub max_sessions_per_tick: usize,/// Minimum age after SessionEnd before a session becomes eligible.pub min_session_age_secs: u64,diff --git a/crates/ai-memory-cli/templates/config.default.toml b/crates/ai-memory-cli/templates/config.default.tomlindex 11fb6599..4129933e 100644--- a/crates/ai-memory-cli/templates/config.default.toml+++ b/crates/ai-memory-cli/templates/config.default.toml@@ -77,11 +77,13 @@ allowlist = []# Auto-improvement reviewer.#-# The background scheduler reviews newly-completed sessions when an LLM provider-# is configured. Approval is a separate stage: by default proposals are staged-# for audit and immediately approved through the normal wiki write path. Set-# `require_approval = true` to keep scheduler and manual-run proposals pending-# until an admin runs `ai-memory pending-writes approve <id>`.+# The background scheduler reviews newly-completed sessions in every project+# when an LLM provider is configured. Ticks are non-overlapping: long all-project+# review passes delay the next tick instead of starting another copy. Approval is+# a separate stage: by default proposals are staged for audit and immediately+# approved through the normal wiki write path. Set `require_approval = true` to+# keep scheduler and manual-run proposals pending until an admin runs+# `ai-memory pending-writes approve <id>`.## Older configs may still contain an `[auto_improve] mode = ...` line. That key# is ignored by current ai-memory and can be removed when convenient.@@ -99,5 +101,5 @@ pending_path = "_pending/auto-improve"[auto_improve.scheduler]enabled = trueinterval_secs = 3600-max_sessions_per_tick = 1+max_sessions_per_tick = 1 # per projectmin_session_age_secs = 600diff --git a/crates/ai-memory-core/src/routing_snippet.rs b/crates/ai-memory-core/src/routing_snippet.rsindex 8dcfd652..e3e8e47a 100644--- a/crates/ai-memory-core/src/routing_snippet.rs+++ b/crates/ai-memory-core/src/routing_snippet.rs@@ -70,7 +70,7 @@ match the intent to the tool. They do not need to name the tool.| "save context for the next session" / wrapping up / ending this session | `memory_handoff_begin` (session-end only; do **not** use for status/briefing; single-use handoff; terse summary; put detail in `open_questions` + `next_steps` bullets; pass `workspace` + `project` together only for a named sibling workspace/project) || "discard that handoff" / "I created a handoff by mistake" | `memory_handoff_cancel` (requires exact `handoff_id` from `memory_handoff_begin`; marks it expired before the next session sees it) || "consolidate this session" / "compile what we learned" (also runs on PreCompact; at session end only if `AI_MEMORY_CONSOLIDATE_ON_SESSION_END` is set) | `memory_consolidate` |-| "what did we learn from this session?" / "what memory should we add?" / explicit wrap-up learning review | `memory_auto_improve` (manual learning review for a completed session; omit `session_id` for latest completed session; the server also schedules background review for newly completed sessions when configured) |+| "what did we learn from this session?" / "what memory should we add?" / explicit wrap-up learning review | `memory_auto_improve` (manual learning review for a completed session; omit `session_id` for latest completed session; the server also schedules background review for newly completed sessions in every project when configured) || "remember this permanently" / "save a note" / "add an annotation" / durable project knowledge | `memory_write_page` (write a wiki page; do **not** use handoff for permanent notes; put the title as a `# H1` on the first line of `body` and omit the `title` arg — ai-memory derives it from the H1) || "read the page about X" / "show me the full content of Y" / "open the page on Z" | `memory_read_page` (full body; pass a query to search or `path` for a direct lookup; pass `workspace` + `project` together only for a named sibling workspace/project) || "delete the page X" / "remove that note" | `memory_delete_page` (by exact `path`; idempotent; pass `workspace` + `project` together only for a named sibling workspace/project) |@@ -124,8 +124,8 @@ query specific error/subsystem terms before designing a fix.### Learning Review-The server schedules background auto-improvement for newly completed sessions-when an LLM provider is configured. `memory_auto_improve` is the manual version:+The server schedules background auto-improvement for newly completed sessions in+every project when an LLM provider is configured. `memory_auto_improve` is the manual version:use it when the user asks what durable lessons this session suggests, or atexplicit wrap-up when reviewing proposed memory would be useful. Scheduled andmanual runs apply or stage validated edits through the auto-improvement approvaldiff --git a/crates/ai-memory-mcp/src/server.rs b/crates/ai-memory-mcp/src/server.rsindex 89722735..7f25d903 100644--- a/crates/ai-memory-mcp/src/server.rs+++ b/crates/ai-memory-mcp/src/server.rs@@ -94,7 +94,7 @@ the conversation calls for them:\n\- `memory_auto_improve` — when the user asks what durable lessons \should be proposed from a completed session, or at explicit wrap-up \when learning review is useful. It is the manual version of the server's \- scheduled auto-improvement loop, reads the latest completed session by \+ all-project scheduled auto-improvement loop, reads the latest completed session by \default, and applies or stages validated edits through the auto-improvement \approval path. Admins can set `[auto_improve.scheduler] enabled = false` \to stop scheduling, or `[auto_improve] require_approval = true` to leave \@@ -1165,7 +1165,7 @@ impl AiMemoryServer {/// Stage durable wiki edit proposals for a completed session.#[tool(- description = "Run manual auto-improvement for one completed session and apply or stage validated wiki edit proposals through the auto-improvement approval path. Use when the user asks what durable lessons should be captured, what memory pages this session suggests, or at explicit wrap-up when a learning review is useful. Omit `session_id` to review the latest completed session in the current project. The server also schedules background review for newly completed sessions when an LLM provider is configured. Admins can set `[auto_improve.scheduler] enabled = false` to stop automatic review, or `[auto_improve] require_approval = true` to leave scheduled and manual proposals pending for review."+ description = "Run manual auto-improvement for one completed session and apply or stage validated wiki edit proposals through the auto-improvement approval path. Use when the user asks what durable lessons should be captured, what memory pages this session suggests, or at explicit wrap-up when a learning review is useful. Omit `session_id` to review the latest completed session in the current project. The server also schedules background review for newly completed sessions in every project when an LLM provider is configured. Admins can set `[auto_improve.scheduler] enabled = false` to stop automatic review, or `[auto_improve] require_approval = true` to leave scheduled and manual proposals pending for review.")]async fn memory_auto_improve(&self,diff --git a/crates/ai-memory-store/src/lib.rs b/crates/ai-memory-store/src/lib.rsindex 6f0b712c..24b48ef0 100644--- a/crates/ai-memory-store/src/lib.rs+++ b/crates/ai-memory-store/src/lib.rs@@ -148,6 +148,15 @@ mod tests {}}+ fn delete_scheduler_state(store: &Store, ws: WorkspaceId, proj: ProjectId) {+ let conn = Connection::open(store.db_path()).unwrap();+ conn.execute(+ "DELETE FROM auto_improve_scheduler_state WHERE workspace_id = ?1 AND project_id = ?2",+ params![ws.as_bytes(), proj.as_bytes()],+ )+ .unwrap();+ }+fn stage_input(ws: WorkspaceId,proj: ProjectId,@@ -1537,6 +1546,7 @@ mod tests {.get_or_create_project(ws, "ai-memory", None).await.unwrap();+ delete_scheduler_state(&store, ws, proj);let historical = SessionId::new();store@@ -1692,6 +1702,121 @@ mod tests {);}+ #[tokio::test]+ async fn auto_improve_scheduler_state_and_candidates_are_per_project() {+ let tmp = TempDir::new().unwrap();+ let store = Store::open(tmp.path()).unwrap();+ let ws = store+ .writer+ .get_or_create_workspace("default")+ .await+ .unwrap();+ let first_project = store+ .writer+ .get_or_create_project(ws, "first", None)+ .await+ .unwrap();+ let second_project = store+ .writer+ .get_or_create_project(ws, "second", None)+ .await+ .unwrap();+ for project_id in [first_project, second_project] {+ delete_scheduler_state(&store, ws, project_id);+ }++ for project_id in [first_project, second_project] {+ let historical = SessionId::new();+ store+ .writer+ .begin_session(NewSession {+ id: historical,+ workspace_id: ws,+ project_id,+ agent_kind: AgentKind::OpenCode,+ cwd: None,+ })+ .await+ .unwrap();+ store.writer.end_session(historical, None).await.unwrap();+ }++ for scope in store.reader.list_all_scopes().await.unwrap() {+ store+ .writer+ .ensure_auto_improve_scheduler_state(scope.workspace_id, scope.project_id)+ .await+ .unwrap();+ }++ tokio::time::sleep(std::time::Duration::from_millis(1)).await;+ let mut expected = Vec::new();+ for project_id in [first_project, second_project] {+ let session_id = SessionId::new();+ store+ .writer+ .begin_session(NewSession {+ id: session_id,+ workspace_id: ws,+ project_id,+ agent_kind: AgentKind::OpenCode,+ cwd: None,+ })+ .await+ .unwrap();+ store.writer.end_session(session_id, None).await.unwrap();+ expected.push((project_id, session_id));+ }++ for (project_id, session_id) in expected {+ let candidates = store+ .reader+ .auto_improve_candidate_sessions(ws, project_id, 0, 10)+ .await+ .unwrap();+ assert_eq!(candidates.len(), 1);+ assert_eq!(candidates[0].session_id, session_id);+ }+ }++ #[tokio::test]+ async fn get_or_create_project_initializes_scheduler_state_before_first_session() {+ let tmp = TempDir::new().unwrap();+ let store = Store::open(tmp.path()).unwrap();+ let ws = store+ .writer+ .get_or_create_workspace("default")+ .await+ .unwrap();+ let proj = store+ .writer+ .get_or_create_project(ws, "brand-new", None)+ .await+ .unwrap();++ let first_session = SessionId::new();+ store+ .writer+ .begin_session(NewSession {+ id: first_session,+ workspace_id: ws,+ project_id: proj,+ agent_kind: AgentKind::OpenCode,+ cwd: None,+ })+ .await+ .unwrap();+ store.writer.end_session(first_session, None).await.unwrap();++ let candidates = store+ .reader+ .auto_improve_candidate_sessions(ws, proj, 0, 10)+ .await+ .unwrap();+ assert_eq!(candidates.len(), 1);+ assert_eq!(candidates[0].session_id, first_session);+ }+#[tokio::test]async fn auto_improve_scheduler_claims_do_not_skip_same_ended_at_sessions() {let tmp = TempDir::new().unwrap();diff --git a/crates/ai-memory-store/src/ops.rs b/crates/ai-memory-store/src/ops.rsindex e5d10999..46cb74fa 100644--- a/crates/ai-memory-store/src/ops.rs+++ b/crates/ai-memory-store/src/ops.rs@@ -139,9 +139,23 @@ pub fn get_or_create_project(id};tx.commit()?;+ if scheduler_state_table_exists(conn)? {+ crate::auto_improve::ensure_scheduler_state(conn, *workspace_id, id)?;+ }Ok(id)}+fn scheduler_state_table_exists(conn: &Connection) -> StoreResult<bool> {+ Ok(conn+ .query_row(+ "SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'auto_improve_scheduler_state'",+ [],+ |_| Ok(()),+ )+ .optional()?+ .is_some())+}+/// Insert a workspace with an **explicit id**, idempotent. Unlike/// [`get_or_create_workspace`] (which mints a fresh id), this preserves the id/// the caller already holds — used by `reindex`, which recovers the id from thediff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.mdindex 14e47152..e83c6422 100644--- a/docs/ARCHITECTURE.md+++ b/docs/ARCHITECTURE.md@@ -29,9 +29,11 @@ background reconciliation or provider-backed maintenance. The core invariant isunchanged: the markdown wiki is the source of truth, and SQLite is the derivedindex for search, sessions, observations, handoffs, audit, and embeddings.Auto-improvement sits on the provider-backed maintenance side: the server-schedules reviews for newly completed sessions, records validated proposals in-the pending-writes audit trail, and auto-approves them through the normal wiki-write path by default. Scheduling and approval are separate. Admins can set+schedules reviews for newly completed sessions in every project, records+validated proposals in the pending-writes audit trail, and auto-approves them+through the normal wiki write path by default. Scheduler ticks are+non-overlapping; long all-project review passes delay the next tick instead of+starting another copy. Scheduling and approval are separate. Admins can set`[auto_improve.scheduler] enabled = false` to stop background review, or`[auto_improve] require_approval = true` to leave scheduled and manual proposalspending for review.@@ -59,7 +61,7 @@ pending for review.that summary into a richer durable page or fans out into amulti-page batch under `concepts/`, `decisions/`, `gotchas/`.5. When an LLM provider is configured, the auto-improvement scheduler reviews- newly completed sessions outside hook latency. It records validated+ newly completed sessions across all projects outside hook latency. It records validated`concepts/`, `decisions/`, `gotchas/`, `procedures/`, and `_rules/` proposalsin the pending-writes audit trail, then approves them through the wikimutation path by default. The scheduler initializes a per-project first-run@@ -340,7 +342,7 @@ pending_path = "_pending/auto-improve"[auto_improve.scheduler] # background review; separate from approvalenabled = trueinterval_secs = 3600-max_sessions_per_tick = 1+max_sessions_per_tick = 1 # per project; scheduler ticks do not overlapmin_session_age_secs = 600```diff --git a/docs/auto-improvement-loop.md b/docs/auto-improvement-loop.mdindex f4f39d24..263fed88 100644--- a/docs/auto-improvement-loop.md+++ b/docs/auto-improvement-loop.md@@ -1,7 +1,7 @@# Optional Auto-Improvement Loop Research> Status: research plus implemented production notes. The server schedules-> auto-improvement for newly completed sessions when an LLM provider is+> auto-improvement for newly completed sessions in every project when an LLM provider is> configured. Manual CLI/admin/MCP auto-improvement remains available for> targeted runs and catch-up. Both paths record validated proposals in the> pending-writes audit trail and auto-approve them through the normal wiki write@@ -251,7 +251,8 @@ Default-available auto-improvement must not surprise existing installs:contain an `[auto_improve] mode = ...` key; current ai-memory ignores thatlegacy key. Operators can remove the line when convenient.2. Session-end triggering stays off; the bounded background scheduler runs- outside hook latency and sleeps for its configured interval between ticks.+ outside hook latency and sleeps for its configured interval after each+ non-overlapping all-project tick.3. The scheduler initializes a first-run watermark per workspace/project andrecords a per-session claim before scheduled LLM work. Historical sessions arenot reviewed automatically on upgrade, and failed scheduled reviews are not@@ -286,7 +287,7 @@ pending_path = "_pending/auto-improve"[auto_improve.scheduler]enabled = true # false disables background review onlyinterval_secs = 3600 # 0 disables background review only-max_sessions_per_tick = 1+max_sessions_per_tick = 1 # per project; ticks process projects sequentiallymin_session_age_secs = 600```@@ -440,11 +441,11 @@ Tests:### Phase 3: Background SchedulerStatus: implemented as a server-side scheduler, not a SessionEnd hook trigger.-The scheduler is enabled by default when an LLM provider exists, sleeps for its-configured interval, and reviews only newly completed sessions after the-persisted first-run watermark. It records a per-session claim before calling the-LLM, so scheduled review is at-most-once per completed session unless an admin-reruns auto-improve manually.+The scheduler is enabled by default when an LLM provider exists, sleeps after+each non-overlapping tick, and reviews newly completed sessions across every+project after each project's persisted first-run watermark. It records a+per-session claim before calling the LLM, so scheduled review is at-most-once per+completed session unless an admin reruns auto-improve manually.Tests:diff --git a/docs/design-decisions.md b/docs/design-decisions.mdindex deeb63c5..0e9a0e2f 100644--- a/docs/design-decisions.md+++ b/docs/design-decisions.md@@ -140,9 +140,9 @@ Decay/forget runs as a separate `memory_forget_sweep` job: applies the retentionAuto-improvement work stays separate from normal session consolidation. Thereviewer notes and staged design are in[`docs/auto-improvement-loop.md`](auto-improvement-loop.md). The short version:-learning review is scheduled for newly completed sessions when an LLM provider-is configured, and manual CLI/admin/MCP runs remain available for catch-up or-targeted reruns. Scheduling and approval are separate: `[auto_improve.scheduler]`+learning review is scheduled for newly completed sessions in every project when+an LLM provider is configured, and manual CLI/admin/MCP runs remain available for+catch-up or targeted reruns. Scheduling and approval are separate: `[auto_improve.scheduler]`controls background review, while `[auto_improve] require_approval = true` keepsscheduled and manual proposals pending for human approval instead of applyingthem automatically. All writes remain scoped through the shared resolver/auth