Solution for long term memory for agent coding CLIs and to facilitate handoff between different agent vendors
Rust
feat(auto-improve): harden proposal review loop
AkitaOnRails87c2a61a718b
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex 9ee776ef..141aaf37 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -7,6 +7,30 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0## [Unreleased]+### Added+- Auto-improvement reviews can now stage bounded patch proposals for existing+ `_rules/` and `procedures/` pages using append, add-section, and checked+ replace-section edits, with base-body hashes guarding materialize-to-stage+ races.+- Auto-improvement patch proposals now honor a per-run edit budget, and final+ `_rules/` / `procedures/` pages have configurable token budgets to prevent+ reviewer runs from growing policy or procedure pages too aggressively.+- Auto-improvement now keeps a scoped rejection buffer for human rejects,+ approval conflicts/failures, and validator rejected candidates, then feeds a+ bounded summary into future reviewer prompts to avoid repeated failed edits.+- Auto-improvement can now run an optional operator-supplied executable eval gate+ under `[auto_improve.eval]` after LLM validation and before staging/approval for+ selected targets (default `_rules` and `procedures`). The gate is disabled by+ default, receives proposal JSON on stdin, fails closed on command/timeout/JSON+ errors or insufficient score delta, and records eval failures as rejected+ candidates without running from hook paths.++### Fixed+- Auto-improvement eval gates now apply timeouts to the full child interaction,+ cap stdout at 64 KiB, cap eval rejection evidence, and make direct root admin+ requests inherit server eval defaults unless the request explicitly overrides+ them.+## [1.1.3] - 2026-06-20### Fixeddiff --git a/Cargo.lock b/Cargo.lockindex 49e75b16..e887a42b 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -85,6 +85,7 @@ dependencies = ["schemars","serde","serde_json",+ "sha2","tempfile","thiserror 2.0.18","tokio",diff --git a/crates/ai-memory-cli/src/commands/auto_improve.rs b/crates/ai-memory-cli/src/commands/auto_improve.rsindex e4ffb714..3661cab8 100644--- a/crates/ai-memory-cli/src/commands/auto_improve.rs+++ b/crates/ai-memory-cli/src/commands/auto_improve.rs@@ -18,9 +18,21 @@ struct AutoImproveRequest {min_confidence: f32,max_input_tokens: usize,max_proposals_per_run: usize,+ max_patchable_pages: usize,+ max_patchable_body_chars: usize,+ max_edits_per_proposal: usize,+ max_edit_content_chars: usize,+ max_changed_chars_per_proposal: usize,+ max_patch_edits_per_run: usize,+ max_rejection_context: usize,+ rejection_context_days: u32,+ max_final_body_chars: usize,+ max_rule_page_tokens: usize,+ max_procedure_page_tokens: usize,include_raw_fallback: bool,proposal_actor: String,pending_path: String,+ eval: ai_memory_consolidate::AutoImproveEvalConfig,}#[derive(Debug, Deserialize, Serialize)]@@ -62,9 +74,27 @@ pub async fn run(config: &Config, args: AutoImproveArgs) -> Result<()> {min_confidence: args.min_confidence.unwrap_or(settings.min_confidence),max_input_tokens: args.max_input_tokens.unwrap_or(settings.max_input_tokens),max_proposals_per_run: args.max_proposals.unwrap_or(settings.max_proposals_per_run),+ max_patchable_pages: settings.max_patchable_pages,+ max_patchable_body_chars: settings.max_patchable_body_chars,+ max_edits_per_proposal: settings.max_edits_per_proposal,+ max_edit_content_chars: settings.max_edit_content_chars,+ max_changed_chars_per_proposal: settings.max_changed_chars_per_proposal,+ max_patch_edits_per_run: settings.max_patch_edits_per_run,+ max_rejection_context: settings.max_rejection_context,+ rejection_context_days: settings.rejection_context_days,+ max_final_body_chars: settings.max_final_body_chars,+ max_rule_page_tokens: settings.max_rule_page_tokens,+ max_procedure_page_tokens: settings.max_procedure_page_tokens,include_raw_fallback: args.include_raw_fallback || settings.include_raw_fallback,proposal_actor: settings.proposal_actor.clone(),pending_path: settings.pending_path.clone(),+ eval: ai_memory_consolidate::AutoImproveEvalConfig {+ enabled: settings.eval.enabled,+ command: settings.eval.command.clone(),+ timeout_secs: settings.eval.timeout_secs,+ targets: settings.eval.targets.clone(),+ min_delta: settings.eval.min_delta,+ },};let response: StageResponse = post_json(&endpoint, "/admin/auto-improve", &request).await?;diff --git a/crates/ai-memory-cli/src/commands/serve.rs b/crates/ai-memory-cli/src/commands/serve.rsindex aec1c93f..11dbd1a6 100644--- a/crates/ai-memory-cli/src/commands/serve.rs+++ b/crates/ai-memory-cli/src/commands/serve.rs@@ -189,6 +189,9 @@ pub async fn run(config: &Config, args: ServeArgs) -> Result<()> {.with_wiki(wiki.clone()).with_decay_params(config.decay).with_auto_improve_require_approval(config.auto_improve.require_approval)+ .with_auto_improve_review_config(auto_improve_review_config_from_settings(+ &config.auto_improve,+ )).with_active_project(active_project.clone()).with_sanitizer(sanitizer.clone());if let Some(e) = embedder.clone() {@@ -291,6 +294,9 @@ pub async fn run(config: &Config, args: ServeArgs) -> Result<()> {wiki: wiki.clone(),llm: admin_llm,auto_improve_require_approval: config.auto_improve.require_approval,+ auto_improve_review_config: auto_improve_review_config_from_settings(+ &config.auto_improve,+ ),embedder: embedder.clone(),provider_health: provider_health.clone(),decay_params: config.decay,@@ -872,16 +878,7 @@ async fn run_scheduled_auto_improve(ctx: &ScheduledAutoImproveContext<'_>,session_id: SessionId,) -> Result<ScheduledAutoImproveOutcome> {- let cfg = AutoImproveReviewConfig {- min_observations: ctx.settings.min_observations,- min_session_duration_secs: ctx.settings.min_session_duration_secs,- min_confidence: ctx.settings.min_confidence,- max_input_tokens: ctx.settings.max_input_tokens,- max_proposals_per_run: ctx.settings.max_proposals_per_run,- include_raw_fallback: ctx.settings.include_raw_fallback,- proposal_actor: ctx.settings.proposal_actor.clone(),- pending_path: ctx.settings.pending_path.clone(),- };+ let cfg = auto_improve_review_config_from_settings(ctx.settings);let report = run_auto_improve_review(ctx.reader,&**ctx.llm,@@ -915,6 +912,18 @@ async fn run_scheduled_auto_improve("max_input_tokens": cfg.max_input_tokens,"max_proposals_per_run": cfg.max_proposals_per_run,"include_raw_fallback": cfg.include_raw_fallback,+ "max_patchable_pages": cfg.max_patchable_pages,+ "max_patchable_body_chars": cfg.max_patchable_body_chars,+ "max_edits_per_proposal": cfg.max_edits_per_proposal,+ "max_edit_content_chars": cfg.max_edit_content_chars,+ "max_changed_chars_per_proposal": cfg.max_changed_chars_per_proposal,+ "max_patch_edits_per_run": cfg.max_patch_edits_per_run,+ "max_rejection_context": cfg.max_rejection_context,+ "rejection_context_days": cfg.rejection_context_days,+ "max_final_body_chars": cfg.max_final_body_chars,+ "max_rule_page_tokens": cfg.max_rule_page_tokens,+ "max_procedure_page_tokens": cfg.max_procedure_page_tokens,+ "eval": cfg.eval,"require_approval": ctx.settings.require_approval,}),proposal_actor: ActorContext {@@ -971,6 +980,39 @@ async fn run_scheduled_auto_improve(})}+fn auto_improve_review_config_from_settings(+ settings: &AutoImproveSettings,+) -> AutoImproveReviewConfig {+ AutoImproveReviewConfig {+ min_observations: settings.min_observations,+ min_session_duration_secs: settings.min_session_duration_secs,+ min_confidence: settings.min_confidence,+ max_input_tokens: settings.max_input_tokens,+ max_proposals_per_run: settings.max_proposals_per_run,+ include_raw_fallback: settings.include_raw_fallback,+ proposal_actor: settings.proposal_actor.clone(),+ pending_path: settings.pending_path.clone(),+ max_patchable_pages: settings.max_patchable_pages,+ max_patchable_body_chars: settings.max_patchable_body_chars,+ max_edits_per_proposal: settings.max_edits_per_proposal,+ max_edit_content_chars: settings.max_edit_content_chars,+ max_changed_chars_per_proposal: settings.max_changed_chars_per_proposal,+ max_patch_edits_per_run: settings.max_patch_edits_per_run,+ max_rejection_context: settings.max_rejection_context,+ rejection_context_days: settings.rejection_context_days,+ max_final_body_chars: settings.max_final_body_chars,+ max_rule_page_tokens: settings.max_rule_page_tokens,+ max_procedure_page_tokens: settings.max_procedure_page_tokens,+ eval: ai_memory_consolidate::AutoImproveEvalConfig {+ enabled: settings.eval.enabled,+ command: settings.eval.command.clone(),+ timeout_secs: settings.eval.timeout_secs,+ targets: settings.eval.targets.clone(),+ min_delta: settings.eval.min_delta,+ },+ }+}+async fn scheduled_auto_improve_new_proposals(reader: &ReaderPool,workspace_id: WorkspaceId,@@ -980,15 +1022,23 @@ async fn scheduled_auto_improve_new_proposals(let mut proposals = Vec::with_capacity(report.proposals.len());for p in &report.proposals {let path = PagePath::new(p.path.clone())?;- let operation = if reader+ let target_exists = reader.page_body_by_ids(workspace_id, project_id, path.as_str()).await?- .is_some()+ .is_some();+ let operation = if p.edit_mode == "patch"+ || (target_exists && path.as_str() == "_slots/current-focus.md"){AutoImproveProposalOperation::Update} else {AutoImproveProposalOperation::Create};+ let expected_base_body_sha256 = p+ .expected_base_body_sha256+ .as_deref()+ .map(hex_to_sha256)+ .transpose()+ .map_err(|e| anyhow::anyhow!("invalid expected_base_body_sha256: {e}"))?;proposals.push(NewAutoImproveProposal {operation,target_path: path,@@ -1000,11 +1050,26 @@ async fn scheduled_auto_improve_new_proposals(.unwrap_or_else(|_| serde_json::json!([])),body_markdown: p.body_markdown.clone(),artifact_sha256: None,+ edit_mode: Some(p.edit_mode.clone()),+ patch_json: serde_json::to_value(&p.edits).ok(),+ expected_base_body_sha256,});}Ok(proposals)}+fn hex_to_sha256(hex: &str) -> Result<[u8; 32], String> {+ if hex.len() != 64 {+ return Err("expected 64 hex chars".into());+ }+ let mut out = [0_u8; 32];+ for (idx, chunk) in hex.as_bytes().chunks_exact(2).enumerate() {+ let s = std::str::from_utf8(chunk).map_err(|e| e.to_string())?;+ out[idx] = u8::from_str_radix(s, 16).map_err(|e| e.to_string())?;+ }+ Ok(out)+}+async fn configure_embedder(config: &Config,store: &Store,diff --git a/crates/ai-memory-cli/src/config.rs b/crates/ai-memory-cli/src/config.rsindex 14970eb3..d1c1f0e4 100644--- a/crates/ai-memory-cli/src/config.rs+++ b/crates/ai-memory-cli/src/config.rs@@ -378,6 +378,8 @@ pub struct AutoImproveSettings {/// Background scheduler settings. This controls whether reviews are launched/// automatically; it does not control whether accepted proposals are applied.pub scheduler: AutoImproveSchedulerSettings,+ /// Optional executable evaluation gate for selected proposal targets.+ pub eval: AutoImproveEvalSettings,/// Require manual pending-writes approval. Defaults false so validated/// proposals are staged for audit and immediately approved through the/// normal wiki write path.@@ -395,6 +397,28 @@ pub struct AutoImproveSettings {pub max_input_tokens: usize,/// Maximum validated proposals returned from one run.pub max_proposals_per_run: usize,+ /// Maximum existing _rules/ and procedures/ pages included for patch proposals.+ pub max_patchable_pages: usize,+ /// Maximum body chars rendered per patchable target page.+ pub max_patchable_body_chars: usize,+ /// Maximum patch edits per proposal.+ pub max_edits_per_proposal: usize,+ /// Maximum content chars in one patch edit.+ pub max_edit_content_chars: usize,+ /// Maximum aggregate changed chars in one patch proposal.+ pub max_changed_chars_per_proposal: usize,+ /// Maximum patch edits accepted across one review run.+ pub max_patch_edits_per_run: usize,+ /// Maximum recent rejection-buffer entries rendered into prompt context.+ pub max_rejection_context: usize,+ /// Maximum age in days for rejection-buffer prompt context.+ pub rejection_context_days: u32,+ /// Maximum materialized final body size.+ pub max_final_body_chars: usize,+ /// Maximum approximate tokens allowed in one _rules/ page.+ pub max_rule_page_tokens: usize,+ /// Maximum approximate tokens allowed in one procedures/ page.+ pub max_procedure_page_tokens: usize,/// Whether future reviewers may include raw observation fallback details.pub include_raw_fallback: bool,/// Synthetic actor used for autonomous proposal provenance.@@ -403,6 +427,34 @@ pub struct AutoImproveSettings {pub pending_path: String,}+/// `[auto_improve.eval]` optional executable proposal gate settings.+#[derive(Debug, Clone, Serialize, Deserialize)]+#[serde(default)]+pub struct AutoImproveEvalSettings {+ /// Whether the eval command gate is enabled.+ pub enabled: bool,+ /// Executable command plus whitespace-separated args. Executed directly, not through a shell.+ pub command: String,+ /// Timeout per proposal eval command.+ pub timeout_secs: u64,+ /// Wiki path prefixes that require eval when enabled.+ pub targets: Vec<String>,+ /// Required score_after - score_before when scores are present.+ pub min_delta: f64,+}++impl Default for AutoImproveEvalSettings {+ fn default() -> Self {+ Self {+ enabled: false,+ command: String::new(),+ timeout_secs: 120,+ targets: ai_memory_consolidate::default_auto_improve_eval_targets(),+ min_delta: 0.0,+ }+ }+}+/// `[auto_improve.scheduler]` background learning loop settings.#[derive(Debug, Clone, Serialize, Deserialize)]#[serde(default)]@@ -432,6 +484,7 @@ impl Default for AutoImproveSettings {fn default() -> Self {Self {scheduler: AutoImproveSchedulerSettings::default(),+ eval: AutoImproveEvalSettings::default(),require_approval: false,on_session_end: false,min_observations: ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MIN_OBSERVATIONS,@@ -440,6 +493,25 @@ impl Default for AutoImproveSettings {min_confidence: DEFAULT_AUTO_IMPROVE_MIN_CONFIDENCE,max_input_tokens: ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MAX_INPUT_TOKENS,max_proposals_per_run: ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MAX_PROPOSALS,+ max_patchable_pages: ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MAX_PATCHABLE_PAGES,+ max_patchable_body_chars:+ ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MAX_PATCHABLE_BODY_CHARS,+ max_edits_per_proposal:+ ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MAX_EDITS_PER_PROPOSAL,+ max_edit_content_chars:+ ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MAX_EDIT_CONTENT_CHARS,+ max_changed_chars_per_proposal:+ ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MAX_CHANGED_CHARS_PER_PROPOSAL,+ max_patch_edits_per_run:+ ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MAX_PATCH_EDITS_PER_RUN,+ max_rejection_context:+ ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MAX_REJECTION_CONTEXT,+ rejection_context_days:+ ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_REJECTION_CONTEXT_DAYS,+ max_final_body_chars: ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MAX_FINAL_BODY_CHARS,+ max_rule_page_tokens: ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MAX_RULE_PAGE_TOKENS,+ max_procedure_page_tokens:+ ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MAX_PROCEDURE_PAGE_TOKENS,include_raw_fallback: false,proposal_actor: ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_PROPOSAL_ACTOR.into(),pending_path: ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_PENDING_PATH.into(),@@ -860,6 +932,22 @@ mod tests {);assert_eq!(cfg.auto_improve.max_input_tokens, 24_000);assert_eq!(cfg.auto_improve.max_proposals_per_run, 5);+ assert_eq!(cfg.auto_improve.max_patchable_pages, 8);+ assert_eq!(cfg.auto_improve.max_patchable_body_chars, 8_000);+ assert_eq!(cfg.auto_improve.max_edits_per_proposal, 5);+ assert_eq!(cfg.auto_improve.max_edit_content_chars, 4_000);+ assert_eq!(cfg.auto_improve.max_changed_chars_per_proposal, 12_000);+ assert_eq!(cfg.auto_improve.max_patch_edits_per_run, 8);+ assert_eq!(cfg.auto_improve.max_rejection_context, 50);+ assert_eq!(cfg.auto_improve.rejection_context_days, 180);+ assert_eq!(cfg.auto_improve.max_final_body_chars, 32_000);+ assert_eq!(cfg.auto_improve.max_rule_page_tokens, 2_000);+ assert_eq!(cfg.auto_improve.max_procedure_page_tokens, 2_000);+ assert!(!cfg.auto_improve.eval.enabled);+ assert_eq!(cfg.auto_improve.eval.command, "");+ assert_eq!(cfg.auto_improve.eval.timeout_secs, 120);+ assert_eq!(cfg.auto_improve.eval.targets, vec!["_rules", "procedures"]);+ assert_eq!(cfg.auto_improve.eval.min_delta, 0.0);assert!(!cfg.auto_improve.include_raw_fallback);assert_eq!(cfg.auto_improve.proposal_actor, "auto_improve");assert_eq!(cfg.auto_improve.pending_path, "_pending/auto-improve");@@ -936,6 +1024,17 @@ mod tests {min_confidence = 0.9max_input_tokens = 12000max_proposals_per_run = 2+ max_patchable_pages = 3+ max_patchable_body_chars = 4096+ max_edits_per_proposal = 4+ max_edit_content_chars = 1024+ max_changed_chars_per_proposal = 2048+ max_patch_edits_per_run = 6+ max_rejection_context = 7+ rejection_context_days = 14+ max_final_body_chars = 8192+ max_rule_page_tokens = 1000+ max_procedure_page_tokens = 1500include_raw_fallback = trueproposal_actor = "review_bot"pending_path = "_pending/review-bot"@@ -945,6 +1044,13 @@ mod tests {interval_secs = 1800max_sessions_per_tick = 4min_session_age_secs = 30++ [auto_improve.eval]+ enabled = true+ command = "/usr/local/bin/auto-improve-eval --json"+ timeout_secs = 9+ targets = ["_rules"]+ min_delta = 0.05"#,).unwrap();@@ -967,6 +1073,25 @@ mod tests {assert_eq!(cfg.auto_improve.min_confidence, 0.9);assert_eq!(cfg.auto_improve.max_input_tokens, 12_000);assert_eq!(cfg.auto_improve.max_proposals_per_run, 2);+ assert_eq!(cfg.auto_improve.max_patchable_pages, 3);+ assert_eq!(cfg.auto_improve.max_patchable_body_chars, 4_096);+ assert_eq!(cfg.auto_improve.max_edits_per_proposal, 4);+ assert_eq!(cfg.auto_improve.max_edit_content_chars, 1_024);+ assert_eq!(cfg.auto_improve.max_changed_chars_per_proposal, 2_048);+ assert_eq!(cfg.auto_improve.max_patch_edits_per_run, 6);+ assert_eq!(cfg.auto_improve.max_rejection_context, 7);+ assert_eq!(cfg.auto_improve.rejection_context_days, 14);+ assert_eq!(cfg.auto_improve.max_final_body_chars, 8_192);+ assert_eq!(cfg.auto_improve.max_rule_page_tokens, 1_000);+ assert_eq!(cfg.auto_improve.max_procedure_page_tokens, 1_500);+ assert!(cfg.auto_improve.eval.enabled);+ assert_eq!(+ cfg.auto_improve.eval.command,+ "/usr/local/bin/auto-improve-eval --json"+ );+ assert_eq!(cfg.auto_improve.eval.timeout_secs, 9);+ assert_eq!(cfg.auto_improve.eval.targets, vec!["_rules"]);+ assert_eq!(cfg.auto_improve.eval.min_delta, 0.05);assert!(cfg.auto_improve.include_raw_fallback);assert_eq!(cfg.auto_improve.proposal_actor, "review_bot");assert_eq!(cfg.auto_improve.pending_path, "_pending/review-bot");diff --git a/crates/ai-memory-cli/templates/config.default.toml b/crates/ai-memory-cli/templates/config.default.tomlindex 4129933e..a3a94913 100644--- a/crates/ai-memory-cli/templates/config.default.toml+++ b/crates/ai-memory-cli/templates/config.default.toml@@ -98,6 +98,17 @@ include_raw_fallback = falseproposal_actor = "auto_improve"pending_path = "_pending/auto-improve"+# Optional executable evaluation gate for selected proposal targets. Disabled by+# default; operators supply the command and scoring policy. The command is run+# directly (not through a shell) with JSON on stdin and must print JSON such as+# { "score_before": 0.72, "score_after": 0.76, "passed": true }.+[auto_improve.eval]+enabled = false+command = ""+timeout_secs = 120+targets = ["_rules", "procedures"]+min_delta = 0.0+[auto_improve.scheduler]enabled = trueinterval_secs = 3600diff --git a/crates/ai-memory-consolidate/Cargo.toml b/crates/ai-memory-consolidate/Cargo.tomlindex 12c65e87..dccb2259 100644--- a/crates/ai-memory-consolidate/Cargo.toml+++ b/crates/ai-memory-consolidate/Cargo.toml@@ -19,6 +19,7 @@ thiserror.workspace = trueserde.workspace = trueserde_json.workspace = trueschemars.workspace = true+sha2.workspace = truetokio.workspace = truetracing.workspace = truejiff.workspace = truediff --git a/crates/ai-memory-consolidate/src/auto_improve.rs b/crates/ai-memory-consolidate/src/auto_improve.rsindex a0778ebc..544f3f2f 100644--- a/crates/ai-memory-consolidate/src/auto_improve.rs+++ b/crates/ai-memory-consolidate/src/auto_improve.rs@@ -5,26 +5,60 @@//! proposals, and returns a report. CLI/admin code may stage the validated//! proposals after this read-only review returns.-use std::collections::BTreeSet;+use std::collections::{BTreeMap, BTreeSet};+use std::future::Future;+use std::pin::Pin;+use std::process::Stdio;+use std::time::Duration;use ai_memory_core::{Observation, PagePath, ProjectId, SessionId, WorkspaceId};use ai_memory_llm::{ChatMessage, ChatRequest, LlmError, LlmProvider, Role, complete_structured};-use ai_memory_store::{BriefingPage, ReaderPool, StoredPageBody};+use ai_memory_store::{AutoImproveRejectionSummary, BriefingPage, ReaderPool, StoredPageBody};use schemars::JsonSchema;use serde::{Deserialize, Serialize, de};+use sha2::{Digest, Sha256};use thiserror::Error;-use crate::projection::{ObservationProjectionConfig, project_observations};+use crate::projection::{ObservationProjectionConfig, cap_text_with_marker, project_observations};const CHARS_PER_TOKEN: usize = 4;const PROMPT_RESERVE_TOKENS: usize = 1_000;const MAX_PROPOSAL_BODY_CHARS: usize = 32_000;+/// Default number of existing pages included as patchable context.+pub const DEFAULT_AUTO_IMPROVE_MAX_PATCHABLE_PAGES: usize = 8;+/// Default maximum body chars rendered for one patchable target page.+pub const DEFAULT_AUTO_IMPROVE_MAX_PATCHABLE_BODY_CHARS: usize = 8_000;+/// Default maximum patch edits per proposal.+pub const DEFAULT_AUTO_IMPROVE_MAX_EDITS_PER_PROPOSAL: usize = 5;+/// Default maximum content chars in one patch edit.+pub const DEFAULT_AUTO_IMPROVE_MAX_EDIT_CONTENT_CHARS: usize = 4_000;+/// Default maximum aggregate changed chars in one patch proposal.+pub const DEFAULT_AUTO_IMPROVE_MAX_CHANGED_CHARS_PER_PROPOSAL: usize = 12_000;+/// Default maximum patch edits accepted across one review run.+pub const DEFAULT_AUTO_IMPROVE_MAX_PATCH_EDITS_PER_RUN: usize = 8;+/// Default maximum rejection-buffer entries rendered into one review prompt.+pub const DEFAULT_AUTO_IMPROVE_MAX_REJECTION_CONTEXT: usize = 50;+/// Default maximum age for rejection-buffer prompt context.+pub const DEFAULT_AUTO_IMPROVE_REJECTION_CONTEXT_DAYS: u32 = 180;+/// Default maximum materialized final body size.+pub const DEFAULT_AUTO_IMPROVE_MAX_FINAL_BODY_CHARS: usize = MAX_PROPOSAL_BODY_CHARS;+/// Default approximate token budget for one rule page.+pub const DEFAULT_AUTO_IMPROVE_MAX_RULE_PAGE_TOKENS: usize = 2_000;+/// Default approximate token budget for one procedure page.+pub const DEFAULT_AUTO_IMPROVE_MAX_PROCEDURE_PAGE_TOKENS: usize = 2_000;const DEFAULT_REVIEW_MAX_TOKENS: u32 = 16_000;const MAX_SESSION_PAGE_CHARS: usize = 32_000;const SAMPLE_LIMIT_WITH_SESSION_PAGE: usize = 48;const SAMPLE_LIMIT_WITHOUT_SESSION_PAGE: usize = 72;const MAX_OBSERVATION_BODY_CHARS: usize = 1_500;const PROMPT_SCAFFOLD_RESERVE_CHARS: usize = 4_000;+const MAX_REJECTION_CONTEXT_CHARS: usize = 12_000;+const MAX_REJECTION_PATH_CHARS: usize = 256;+const MAX_REJECTION_REASON_CHARS: usize = 512;+const MAX_REJECTION_FINGERPRINT_CHARS: usize = 128;+const MAX_REJECTION_SUMMARY_CHARS: usize = 1_024;+const MAX_EVAL_STDOUT_BYTES: usize = 64 * 1024;+const MAX_EVAL_REASON_CHARS: usize = 2_048;/// Default confidence floor for staged auto-improvement proposals.pub const DEFAULT_AUTO_IMPROVE_MIN_CONFIDENCE: f32 = 0.75;@@ -41,6 +75,39 @@ pub const DEFAULT_AUTO_IMPROVE_PROPOSAL_ACTOR: &str = "auto_improve";/// Default wiki-relative folder for pending proposal sidecar markdown.pub const DEFAULT_AUTO_IMPROVE_PENDING_PATH: &str = "_pending/auto-improve";+/// Default target prefixes guarded by the optional external eval command.+pub fn default_auto_improve_eval_targets() -> Vec<String> {+ vec!["_rules".into(), "procedures".into()]+}++/// Optional executable gate for validated auto-improvement proposals.+#[derive(Debug, Clone, Serialize, Deserialize)]+#[serde(default)]+pub struct AutoImproveEvalConfig {+ /// Whether the external eval gate is enabled.+ pub enabled: bool,+ /// Executable command plus whitespace-separated args. Executed directly, not via a shell.+ pub command: String,+ /// Timeout for one proposal evaluation.+ pub timeout_secs: u64,+ /// Wiki path prefixes that require eval when enabled.+ pub targets: Vec<String>,+ /// Required score_after - score_before when scores are returned.+ pub min_delta: f64,+}++impl Default for AutoImproveEvalConfig {+ fn default() -> Self {+ Self {+ enabled: false,+ command: String::new(),+ timeout_secs: 120,+ targets: default_auto_improve_eval_targets(),+ min_delta: 0.0,+ }+ }+}+/// Configuration for one auto-improvement review.#[derive(Debug, Clone)]pub struct AutoImproveReviewConfig {@@ -60,6 +127,57 @@ pub struct AutoImproveReviewConfig {pub proposal_actor: String,/// Wiki-relative pending proposal sidecar folder.pub pending_path: String,+ /// Maximum existing _rules/ and procedures/ pages included for patch proposals.+ pub max_patchable_pages: usize,+ /// Maximum body chars rendered per patchable target page.+ pub max_patchable_body_chars: usize,+ /// Maximum patch edits per proposal.+ pub max_edits_per_proposal: usize,+ /// Maximum content chars in one patch edit.+ pub max_edit_content_chars: usize,+ /// Maximum aggregate changed chars in one patch proposal.+ pub max_changed_chars_per_proposal: usize,+ /// Maximum patch edits accepted across one review run.+ pub max_patch_edits_per_run: usize,+ /// Maximum recent rejected attempts rendered into prompt context.+ pub max_rejection_context: usize,+ /// Maximum age in days for rejected attempts rendered into prompt context.+ pub rejection_context_days: u32,+ /// Maximum materialized final body size.+ pub max_final_body_chars: usize,+ /// Maximum approximate tokens allowed in a final _rules/ page.+ pub max_rule_page_tokens: usize,+ /// Maximum approximate tokens allowed in a final procedures/ page.+ pub max_procedure_page_tokens: usize,+ /// Optional executable eval gate settings.+ pub eval: AutoImproveEvalConfig,+}++impl Default for AutoImproveReviewConfig {+ fn default() -> Self {+ Self {+ min_observations: DEFAULT_AUTO_IMPROVE_MIN_OBSERVATIONS,+ min_session_duration_secs: DEFAULT_AUTO_IMPROVE_MIN_SESSION_DURATION_SECS,+ min_confidence: DEFAULT_AUTO_IMPROVE_MIN_CONFIDENCE,+ max_input_tokens: DEFAULT_AUTO_IMPROVE_MAX_INPUT_TOKENS,+ max_proposals_per_run: DEFAULT_AUTO_IMPROVE_MAX_PROPOSALS,+ include_raw_fallback: false,+ proposal_actor: DEFAULT_AUTO_IMPROVE_PROPOSAL_ACTOR.into(),+ pending_path: DEFAULT_AUTO_IMPROVE_PENDING_PATH.into(),+ max_patchable_pages: DEFAULT_AUTO_IMPROVE_MAX_PATCHABLE_PAGES,+ max_patchable_body_chars: DEFAULT_AUTO_IMPROVE_MAX_PATCHABLE_BODY_CHARS,+ max_edits_per_proposal: DEFAULT_AUTO_IMPROVE_MAX_EDITS_PER_PROPOSAL,+ max_edit_content_chars: DEFAULT_AUTO_IMPROVE_MAX_EDIT_CONTENT_CHARS,+ max_changed_chars_per_proposal: DEFAULT_AUTO_IMPROVE_MAX_CHANGED_CHARS_PER_PROPOSAL,+ max_patch_edits_per_run: DEFAULT_AUTO_IMPROVE_MAX_PATCH_EDITS_PER_RUN,+ max_rejection_context: DEFAULT_AUTO_IMPROVE_MAX_REJECTION_CONTEXT,+ rejection_context_days: DEFAULT_AUTO_IMPROVE_REJECTION_CONTEXT_DAYS,+ max_final_body_chars: DEFAULT_AUTO_IMPROVE_MAX_FINAL_BODY_CHARS,+ max_rule_page_tokens: DEFAULT_AUTO_IMPROVE_MAX_RULE_PAGE_TOKENS,+ max_procedure_page_tokens: DEFAULT_AUTO_IMPROVE_MAX_PROCEDURE_PAGE_TOKENS,+ eval: AutoImproveEvalConfig::default(),+ }+ }}/// Errors raised by the reviewer.@@ -83,6 +201,9 @@ pub enum AutoImproveError {/// Session that failed the scope check.session_id: SessionId,},+ /// Optional external eval command failed unexpectedly.+ #[error("auto-improve eval gate failed: {0}")]+ Eval(String),}/// Result alias for auto-improvement review.@@ -158,12 +279,45 @@ pub struct AutoImproveProposal {/// Markdown body without frontmatter.#[serde(default, alias = "body", alias = "markdown", alias = "content")]pub body_markdown: String,+ /// `full_page` (default) or `patch`.+ #[serde(default = "default_edit_mode")]+ pub edit_mode: String,+ /// Patch edits for existing _rules/ or procedures/ pages.+ #[serde(default)]+ pub edits: Vec<AutoImprovePatchEdit>,+ /// Base body sha256 computed when a patch is materialized.+ #[serde(default)]+ pub expected_base_body_sha256: Option<String>,+}++/// One anchored patch edit.+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]+pub struct AutoImprovePatchEdit {+ /// `append`, `add_section`, or `replace_section`.+ #[serde(default)]+ pub op: String,+ /// Exact markdown heading anchor, including marker, e.g. `## Release process`.+ #[serde(default)]+ pub anchor: String,+ /// Markdown content to insert or replace.+ #[serde(default)]+ pub content: String,+ /// Required for replace_section; sha256 of the anchored section span.+ #[serde(default)]+ pub section_sha256: Option<String>,+ /// Optional surrounding context for model readability.+ #[serde(default)]+ pub context: Option<String>,}fn default_operation() -> String {"create_or_update".into()}+fn default_edit_mode() -> String {+ "full_page".into()+}+/// A candidate the reviewer or validator rejected.#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]pub struct AutoImproveRejectedCandidate {@@ -173,6 +327,18 @@ pub struct AutoImproveRejectedCandidate {/// Evidence label or short detail.#[serde(default)]pub evidence: String,+ /// Optional target path for validator/model rejections.+ #[serde(default)]+ pub target_path: Option<String>,+ /// Optional semantic kind for the rejected edit.+ #[serde(default)]+ pub kind: Option<String>,+ /// Optional requested operation.+ #[serde(default)]+ pub operation: Option<String>,+ /// Optional edit mode.+ #[serde(default)]+ pub edit_mode: Option<String>,}/// Structured response requested from the LLM.@@ -267,15 +433,32 @@ pub async fn run_auto_improve_review(let session_page = reader.page_body_by_ids(workspace_id, project_id, &session_page_path).await?;- let existing_index = ExistingPageIndex::from_pages(&briefing.recent_pages);+ let patchable_pages = load_patchable_pages(+ reader,+ workspace_id,+ project_id,+ &briefing.recent_pages,+ &cfg,+ )+ .await?;+ let rejection_context = load_rejection_context(reader, workspace_id, project_id, &cfg).await?;let prompt_input = build_prompt_input(session_id,&observations,duration,session_page.as_ref(),&briefing.recent_pages,+ &patchable_pages,+ &rejection_context,&cfg,);+ let prompt_patchable_pages: Vec<_> = patchable_pages+ .iter()+ .filter(|page| prompt_input.patchable_paths.contains(&page.path))+ .cloned()+ .collect();+ let existing_index =+ ExistingPageIndex::from_pages(&briefing.recent_pages, &prompt_patchable_pages);let estimated_input_tokens = estimate_tokens(&prompt_input.prompt);let request = ChatRequest {system: Some(AUTO_IMPROVE_SYSTEM_PROMPT.to_string()),@@ -287,10 +470,20 @@ pub async fn run_auto_improve_review(temperature: Some(0.1),};let raw: AutoImproveLlmResponse = complete_structured(llm, request).await?;- let (proposals, mut rejected_candidates, mut warnings) =+ let (mut proposals, mut rejected_candidates, mut warnings) =validate_response(raw, &cfg, &existing_index);rejected_candidates.extend(prompt_input.rejected_candidates);warnings.extend(prompt_input.warnings);+ apply_eval_gate(+ reader,+ workspace_id,+ project_id,+ &cfg.eval,+ &mut proposals,+ &mut rejected_candidates,+ &mut warnings,+ )+ .await?;Ok(AutoImproveReport {session_id: session_id.to_string(),@@ -316,20 +509,349 @@ pub async fn run_auto_improve_review(})}+#[derive(Debug, Serialize)]+struct AutoImproveEvalRequest<'a> {+ path: &'a str,+ kind: &'a str,+ operation: &'a str,+ edit_mode: &'a str,+ title: &'a str,+ confidence: f32,+ rationale: &'a str,+ before_body: &'a str,+ after_body: &'a str,+ expected_base_body_sha256: Option<&'a str>,+}++#[derive(Debug, Deserialize)]+struct AutoImproveEvalResponse {+ passed: bool,+ score_before: Option<f64>,+ score_after: Option<f64>,+ #[serde(default)]+ reason: Option<String>,+}++async fn apply_eval_gate(+ reader: &ReaderPool,+ workspace_id: WorkspaceId,+ project_id: ProjectId,+ eval: &AutoImproveEvalConfig,+ proposals: &mut Vec<AutoImproveProposal>,+ rejected: &mut Vec<AutoImproveRejectedCandidate>,+ warnings: &mut Vec<String>,+) -> AutoImproveResult<()> {+ if !eval.enabled {+ return Ok(());+ }+ let mut before_bodies = BTreeMap::new();+ for proposal in proposals.iter() {+ if !eval_targets_path(eval, &proposal.path) {+ continue;+ }+ let before_body = reader+ .page_body_by_ids(workspace_id, project_id, &proposal.path)+ .await?+ .map(|page| page.body)+ .unwrap_or_default();+ before_bodies.insert(proposal.path.clone(), before_body);+ }+ apply_eval_gate_with_before_bodies(eval, proposals, rejected, warnings, &before_bodies).await;+ Ok(())+}++async fn apply_eval_gate_with_before_bodies(+ eval: &AutoImproveEvalConfig,+ proposals: &mut Vec<AutoImproveProposal>,+ rejected: &mut Vec<AutoImproveRejectedCandidate>,+ warnings: &mut Vec<String>,+ before_bodies: &BTreeMap<String, String>,+) {+ if !eval.enabled {+ return;+ }+ if eval.command.trim().is_empty() {+ warnings.push(+ "auto-improve eval gate enabled without a command; targeted proposals rejected".into(),+ );+ }++ let mut accepted = Vec::with_capacity(proposals.len());+ for mut proposal in proposals.drain(..) {+ if !eval_targets_path(eval, &proposal.path) {+ accepted.push(proposal);+ continue;+ }+ let before_body = before_bodies.get(&proposal.path).map_or("", String::as_str);+ match run_eval_for_proposal(eval, &proposal, before_body).await {+ Ok(outcome) => {+ let delta = outcome+ .score_before+ .zip(outcome.score_after)+ .map(|(before, after)| after - before);+ let delta_ok = delta.is_none_or(|value| value >= eval.min_delta);+ if outcome.passed && delta_ok {+ proposal.evidence.push(AutoImproveEvidence {+ page: "auto_improve_eval".into(),+ quote: format_eval_evidence(&outcome, delta),+ });+ accepted.push(proposal);+ } else {+ rejected.push(eval_rejection(+ "eval_gate_failed",+ &proposal,+ format_eval_failure(&outcome, delta, eval.min_delta),+ ));+ }+ }+ Err(EvalRunError::Timeout) => rejected.push(eval_rejection(+ "eval_gate_timeout",+ &proposal,+ format!("eval command timed out after {}s", eval.timeout_secs),+ )),+ Err(EvalRunError::Error(message)) => {+ rejected.push(eval_rejection("eval_gate_error", &proposal, message))+ }+ }+ }+ *proposals = accepted;+}++fn eval_targets_path(eval: &AutoImproveEvalConfig, path: &str) -> bool {+ eval.targets.iter().any(|target| {+ let target = target.trim().trim_end_matches('/');+ !target.is_empty() && (path == target || path.starts_with(&format!("{target}/")))+ })+}++#[derive(Debug)]+enum EvalRunError {+ Timeout,+ Error(String),+}++async fn run_eval_for_proposal(+ eval: &AutoImproveEvalConfig,+ proposal: &AutoImproveProposal,+ before_body: &str,+) -> Result<AutoImproveEvalResponse, EvalRunError> {+ let mut parts = eval.command.split_whitespace();+ let Some(program) = parts.next() else {+ return Err(EvalRunError::Error("eval command is empty".into()));+ };+ let input = AutoImproveEvalRequest {+ path: &proposal.path,+ kind: &proposal.kind,+ operation: &proposal.operation,+ edit_mode: &proposal.edit_mode,+ title: &proposal.title,+ confidence: proposal.confidence,+ rationale: &proposal.rationale,+ before_body,+ after_body: &proposal.body_markdown,+ expected_base_body_sha256: proposal.expected_base_body_sha256.as_deref(),+ };+ let stdin = serde_json::to_vec(&input).map_err(|e| EvalRunError::Error(e.to_string()))?;+ let mut child = tokio::process::Command::new(program)+ .args(parts)+ .stdin(Stdio::piped())+ .stdout(Stdio::piped())+ .stderr(Stdio::null())+ .kill_on_drop(true)+ .spawn()+ .map_err(|e| EvalRunError::Error(format!("failed to start eval command: {e}")))?;+ let interaction = async move {+ let Some(mut child_stdin) = child.stdin.take() else {+ return Err(EvalRunError::Error("eval command stdin unavailable".into()));+ };+ let Some(mut child_stdout) = child.stdout.take() else {+ return Err(EvalRunError::Error(+ "eval command stdout unavailable".into(),+ ));+ };++ let mut write_done = false;+ let mut stdout_done = false;+ let mut status_done = false;+ let mut stdout = Vec::new();+ let mut status = None;+ let mut write_fut: Pin<Box<dyn Future<Output = Result<(), EvalRunError>> + Send>> =+ Box::pin(async move {+ use tokio::io::AsyncWriteExt;+ child_stdin+ .write_all(&stdin)+ .await+ .map_err(|e| EvalRunError::Error(format!("failed to write eval stdin: {e}")))?;+ child_stdin+ .shutdown()+ .await+ .map_err(|e| EvalRunError::Error(format!("failed to close eval stdin: {e}")))+ });+ let mut stdout_fut: Pin<Box<dyn Future<Output = Result<Vec<u8>, EvalRunError>> + Send>> =+ Box::pin(async move { read_eval_stdout_capped(&mut child_stdout).await });+ let mut wait_fut = Box::pin(child.wait());++ loop {+ tokio::select! {+ write_result = &mut write_fut, if !write_done => {+ write_result?;+ write_done = true;+ }+ stdout_result = &mut stdout_fut, if !stdout_done => {+ stdout = stdout_result?;+ stdout_done = true;+ if status_done {+ break;+ }+ }+ status_result = &mut wait_fut, if !status_done => {+ status = Some(status_result.map_err(|e| EvalRunError::Error(format!("eval command failed: {e}")))?);+ status_done = true;+ if stdout_done {+ break;+ }+ }+ }+ }+ let status =+ status.ok_or_else(|| EvalRunError::Error("eval command status unavailable".into()))?;+ Ok((status, stdout))+ };++ let (status, stdout) =+ tokio::time::timeout(Duration::from_secs(eval.timeout_secs), interaction)+ .await+ .map_err(|_| EvalRunError::Timeout)??;+ if !status.success() {+ return Err(EvalRunError::Error(format!(+ "eval command exited with status {}",+ status+ )));+ }+ serde_json::from_slice::<AutoImproveEvalResponse>(&stdout)+ .map_err(|e| EvalRunError::Error(format!("invalid eval JSON: {e}")))+}++async fn read_eval_stdout_capped<R>(reader: &mut R) -> Result<Vec<u8>, EvalRunError>+where+ R: tokio::io::AsyncRead + Unpin,+{+ use tokio::io::AsyncReadExt;++ let mut out = Vec::new();+ let mut buf = [0_u8; 8192];+ loop {+ let n = reader+ .read(&mut buf)+ .await+ .map_err(|e| EvalRunError::Error(format!("failed to read eval stdout: {e}")))?;+ if n == 0 {+ return Ok(out);+ }+ if out.len().saturating_add(n) > MAX_EVAL_STDOUT_BYTES {+ return Err(EvalRunError::Error(format!(+ "eval stdout exceeded {} bytes",+ MAX_EVAL_STDOUT_BYTES+ )));+ }+ out.extend_from_slice(&buf[..n]);+ }+}++fn format_eval_evidence(outcome: &AutoImproveEvalResponse, delta: Option<f64>) -> String {+ match (outcome.score_before, outcome.score_after, delta) {+ (Some(before), Some(after), Some(delta)) => {+ format!(+ "eval passed; score_before={before:.4}, score_after={after:.4}, delta={delta:.4}"+ )+ }+ _ => "eval passed".into(),+ }+}++fn format_eval_failure(+ outcome: &AutoImproveEvalResponse,+ delta: Option<f64>,+ min_delta: f64,+) -> String {+ let reason = cap_text_with_marker(+ outcome.reason.as_deref().unwrap_or("eval did not pass"),+ MAX_EVAL_REASON_CHARS,+ "eval reason",+ );+ match (+ outcome.passed,+ outcome.score_before,+ outcome.score_after,+ delta,+ ) {+ (passed, Some(before), Some(after), Some(delta)) => format!(+ "passed={passed}; score_before={before:.4}; score_after={after:.4}; delta={delta:.4}; min_delta={min_delta:.4}; {reason}"+ ),+ (passed, _, _, _) => format!("passed={passed}; {reason}"),+ }+}++fn eval_rejection(+ reason: &str,+ proposal: &AutoImproveProposal,+ evidence: String,+) -> AutoImproveRejectedCandidate {+ AutoImproveRejectedCandidate {+ reason: reason.into(),+ evidence: cap_text_with_marker(+ &evidence,+ MAX_REJECTION_SUMMARY_CHARS,+ "eval rejection evidence",+ ),+ target_path: Some(proposal.path.clone()),+ kind: Some(proposal.kind.clone()),+ operation: Some(proposal.operation.clone()),+ edit_mode: Some(proposal.edit_mode.clone()),+ }+}+struct PromptInput {prompt: String,+ patchable_paths: BTreeSet<String>,rejected_candidates: Vec<AutoImproveRejectedCandidate>,warnings: Vec<String>,}+#[derive(Debug, Default)]+struct RenderedPatchablePages {+ text: String,+ included_paths: BTreeSet<String>,+}+#[derive(Debug, Default)]struct ExistingPageIndex {paths: BTreeSet<String>,titles: BTreeSet<String>,+ patchable: BTreeMap<String, PatchablePageContext>,+}++#[derive(Debug, Clone)]+struct PatchablePageContext {+ path: String,+ title: String,+ kind: String,+ body: String,+ body_sha256: String,+ sections: Vec<MarkdownSection>,+}++#[derive(Debug, Clone)]+struct MarkdownSection {+ anchor: String,+ level: usize,+ start: usize,+ end: usize,+ sha256: String,}impl ExistingPageIndex {- fn from_pages(pages: &[BriefingPage]) -> Self {+ fn from_pages(pages: &[BriefingPage], patchable_pages: &[PatchablePageContext]) -> Self {Self {paths: pages.iter().map(|page| page.path.clone()).collect(),titles: pages@@ -337,6 +859,10 @@ impl ExistingPageIndex {.map(|page| normalize_title(&page.title)).filter(|title| !title.is_empty()).collect(),+ patchable: patchable_pages+ .iter()+ .map(|page| (page.path.clone(), page.clone()))+ .collect(),}}@@ -348,6 +874,10 @@ impl ExistingPageIndex {let normalized = normalize_title(title);!normalized.is_empty() && self.titles.contains(&normalized)}++ fn patchable(&self, path: &str) -> Option<&PatchablePageContext> {+ self.patchable.get(path)+ }}fn normalize_title(title: &str) -> String {@@ -358,12 +888,73 @@ fn normalize_title(title: &str) -> String {.to_lowercase()}+async fn load_patchable_pages(+ reader: &ReaderPool,+ workspace_id: WorkspaceId,+ project_id: ProjectId,+ recent_pages: &[BriefingPage],+ cfg: &AutoImproveReviewConfig,+) -> AutoImproveResult<Vec<PatchablePageContext>> {+ let mut out = Vec::new();+ for page in recent_pages+ .iter()+ .filter(|p| p.path.starts_with("_rules/") || p.path.starts_with("procedures/"))+ .take(cfg.max_patchable_pages)+ {+ if let Some(body) = reader+ .page_body_by_ids(workspace_id, project_id, &page.path)+ .await?+ {+ let sections = parse_markdown_sections(&body.body);+ out.push(PatchablePageContext {+ path: page.path.clone(),+ title: page.title.clone(),+ kind: page.kind.clone(),+ body_sha256: sha256_hex(body.body.as_bytes()),+ body: body.body,+ sections,+ });+ }+ }+ Ok(out)+}++async fn load_rejection_context(+ reader: &ReaderPool,+ workspace_id: WorkspaceId,+ project_id: ProjectId,+ cfg: &AutoImproveReviewConfig,+) -> AutoImproveResult<Vec<AutoImproveRejectionSummary>> {+ if cfg.max_rejection_context == 0 || cfg.rejection_context_days == 0 {+ return Ok(Vec::new());+ }+ let age_micros = i64::from(cfg.rejection_context_days)+ .saturating_mul(24)+ .saturating_mul(60)+ .saturating_mul(60)+ .saturating_mul(1_000_000);+ let since = jiff::Timestamp::now()+ .as_microsecond()+ .saturating_sub(age_micros);+ Ok(reader+ .recent_auto_improve_rejections(+ workspace_id,+ project_id,+ cfg.max_rejection_context,+ Some(since),+ )+ .await?)+}++#[allow(clippy::too_many_arguments)]fn build_prompt_input(session_id: SessionId,observations: &[Observation],duration_secs: u64,session_page: Option<&StoredPageBody>,recent_pages: &[BriefingPage],+ patchable_pages: &[PatchablePageContext],+ rejection_context: &[AutoImproveRejectionSummary],cfg: &AutoImproveReviewConfig,) -> PromptInput {let mut warnings = Vec::new();@@ -372,14 +963,25 @@ fn build_prompt_input(let usable_chars = usable_tokens.saturating_mul(CHARS_PER_TOKEN);let recent = render_recent_pages(recent_pages);+ let patchable_budget = usable_chars / 4;+ let patchable = render_patchable_pages(+ patchable_pages,+ cfg.max_patchable_body_chars,+ patchable_budget,+ &mut warnings,+ );let session_page_budget = session_page.map(|_| usable_chars / 3).unwrap_or(0).min(MAX_SESSION_PAGE_CHARS);let session_page_section =render_session_page(session_page, session_page_budget, &mut warnings);+ let rejection_budget = rejection_context_char_budget(usable_chars);+ let rejection_text = render_rejection_context(rejection_context, rejection_budget);let observation_budget = usable_chars.saturating_sub(recent.len())+ .saturating_sub(patchable.text.len())+ .saturating_sub(rejection_text.len()).saturating_sub(session_page_section.len()).saturating_sub(PROMPT_SCAFFOLD_RESERVE_CHARS);let selected_limit = if session_page.is_some() {@@ -399,6 +1001,7 @@ fn build_prompt_input(warnings.extend(projected_observations.warnings.iter().cloned());let rendered_observations = projected_observations.text;let selected_count = projected_observations.selected_count;+ let patchable_text = &patchable.text;if selected_count < observations.len() {rejected_candidates.push(AutoImproveRejectedCandidate {@@ -407,6 +1010,10 @@ fn build_prompt_input("selected {selected_count} of {} observations for scalable review",observations.len()),+ target_path: None,+ kind: None,+ operation: None,+ edit_mode: None,});}@@ -419,24 +1026,101 @@ fn build_prompt_input(Max proposals: {}\n\Include raw fallback: {}\n\Pending proposal sidecar path: {}\n\n\- Existing project pages, for duplicate avoidance. Do not target these existing paths or titles; diff-based update proposals are a later phase:\n{recent}\n\n\+ Existing project pages, for duplicate avoidance. Full-page proposals must not target these existing paths or titles except _slots/current-focus.md:\n{recent}\n\n\+ Patchable existing target context. Patch mode is allowed only for these listed _rules/ and procedures/ paths. Use exact markdown heading anchors including markers. Do not request patches for pages, anchors, or bodies not included here. delete_section is unsupported. Budgets: max edits/proposal {}, max patch edits/run {}, max content chars/edit {}, max changed chars/proposal {}, max final body chars {}, max rule page tokens {}, max procedure page tokens {}.\n{patchable_text}\n\n\+ Recent rejected auto-improvement attempts for this workspace/project. Avoid repeating these target/reason/fingerprint patterns unless the session provides clearly new evidence:\n{rejection_text}\n\n\Consolidated session page, primary source when present:\n{session_page_section}\n\n\Selected observations, sampled for scale and supporting evidence:\n{rendered_observations}\n\n\- Return proposals only for durable lessons. Prefer gotchas/, decisions/, concepts/, procedures/, _rules/, _slots/current-focus.md, or notes/. Use _rules/ exactly for rules; never rules/. Body markdown must begin with '# <title>'. Reject no-activity sessions, smoke tests, release markers, one-off task narratives, transient failures, generic routing snippets, and agent instruction text unless the session explicitly changed project policy.",+ Return proposals only for durable lessons. Prefer gotchas/, decisions/, concepts/, procedures/, _rules/, _slots/current-focus.md, or notes/. Use _rules/ exactly for rules; never rules/. Full-page proposal body markdown must begin with '# <title>'; patch proposals use edits and are materialized by validation. Full-page and materialized patch final bodies for _rules/ and procedures/ must stay within their page token budgets. Reject no-activity sessions, smoke tests, release markers, one-off task narratives, transient failures, generic routing snippets, and agent instruction text unless the session explicitly changed project policy.",observations.len(),cfg.min_confidence,cfg.max_proposals_per_run,cfg.include_raw_fallback,cfg.pending_path,+ cfg.max_edits_per_proposal,+ cfg.max_patch_edits_per_run,+ cfg.max_edit_content_chars,+ cfg.max_changed_chars_per_proposal,+ cfg.max_final_body_chars,+ cfg.max_rule_page_tokens,+ cfg.max_procedure_page_tokens,);PromptInput {prompt,+ patchable_paths: patchable.included_paths,rejected_candidates,warnings,}}+fn rejection_context_char_budget(usable_chars: usize) -> usize {+ (usable_chars / 8).min(MAX_REJECTION_CONTEXT_CHARS)+}++fn render_rejection_context(+ rejections: &[AutoImproveRejectionSummary],+ max_total_chars: usize,+) -> String {+ if rejections.is_empty() || max_total_chars == 0 {+ return "(none)".into();+ }+ let mut out = String::new();+ for rejection in rejections {+ let line = format!(+ "- path: {}; kind: {}; op: {}; edit_mode: {}; reason: {}; fingerprint: {}; summary: {}",+ truncate_field(+ rejection.target_path.as_deref().unwrap_or("(none)"),+ MAX_REJECTION_PATH_CHARS+ ),+ truncate_field(+ rejection.kind.as_deref().unwrap_or("(none)"),+ MAX_REJECTION_PATH_CHARS+ ),+ truncate_field(+ rejection.operation.as_deref().unwrap_or("(none)"),+ MAX_REJECTION_PATH_CHARS+ ),+ truncate_field(+ rejection.edit_mode.as_deref().unwrap_or("(none)"),+ MAX_REJECTION_PATH_CHARS+ ),+ truncate_field(&rejection.reason, MAX_REJECTION_REASON_CHARS),+ truncate_field(+ &rejection.normalized_fingerprint,+ MAX_REJECTION_FINGERPRINT_CHARS+ ),+ truncate_field(&rejection.summary, MAX_REJECTION_SUMMARY_CHARS)+ );+ let separator_len = usize::from(!out.is_empty());+ if out.len() + separator_len + line.len() <= max_total_chars {+ if !out.is_empty() {+ out.push('\n');+ }+ out.push_str(&line);+ continue;+ }++ let remaining = max_total_chars.saturating_sub(out.len() + separator_len);+ if remaining > 0 {+ if !out.is_empty() {+ out.push('\n');+ }+ out.push_str(&truncate_to_budget(+ &line,+ remaining,+ " [rejection context truncated]",+ ));+ }+ break;+ }+ if out.is_empty() { "(none)".into() } else { out }+}++fn truncate_field(input: &str, max_chars: usize) -> String {+ truncate_to_budget(input, max_chars, " [truncated]")+}+fn render_session_page(page: Option<&StoredPageBody>,max_chars: usize,@@ -475,6 +1159,122 @@ fn render_recent_pages(pages: &[BriefingPage]) -> String {out}+fn render_patchable_pages(+ pages: &[PatchablePageContext],+ max_body_chars: usize,+ max_total_chars: usize,+ warnings: &mut Vec<String>,+) -> RenderedPatchablePages {+ if pages.is_empty() || max_total_chars == 0 {+ return RenderedPatchablePages {+ text: "(none)".into(),+ included_paths: BTreeSet::new(),+ };+ }+ let mut out = String::new();+ let mut included_paths = BTreeSet::new();+ for page in pages {+ let mut header = format!(+ "path: {}\ntitle: {}\nkind: {}\nbody_sha256: {}\nanchors:\n",+ page.path, page.title, page.kind, page.body_sha256+ );+ for section in &page.sections {+ header.push_str(&format!(+ "- {} | section_sha256: {}\n",+ section.anchor, section.sha256+ ));+ }+ let (body, truncated) = truncate_with_marker(+ &page.body,+ max_body_chars,+ "[patchable target body truncated]",+ );+ if truncated {+ warnings.push(format!(+ "patchable target {} body truncated to {max_body_chars} chars before review",+ page.path+ ));+ }+ let full = format!("{header}body:\n```markdown\n{body}\n```\n\n");+ let outline = format!("{header}body: (omitted by patchable context budget)\n\n");+ if out.len() + full.len() <= max_total_chars {+ out.push_str(&full);+ included_paths.insert(page.path.clone());+ } else if out.len() + outline.len() <= max_total_chars {+ warnings.push(format!(+ "patchable target {} body omitted by patchable context budget",+ page.path+ ));+ out.push_str(&outline);+ included_paths.insert(page.path.clone());+ } else {+ warnings.push("patchable target context truncated by input budget".into());+ break;+ }+ }+ RenderedPatchablePages {+ text: if out.is_empty() { "(none)".into() } else { out },+ included_paths,+ }+}++fn parse_markdown_sections(body: &str) -> Vec<MarkdownSection> {+ let headings = heading_positions(body);+ let mut sections = Vec::new();+ for (idx, (start, level, anchor)) in headings.iter().enumerate() {+ let end = headings[idx + 1..]+ .iter()+ .find(|(_, next_level, _)| next_level <= level)+ .map(|(pos, _, _)| *pos)+ .unwrap_or(body.len());+ sections.push(MarkdownSection {+ anchor: anchor.clone(),+ level: *level,+ start: *start,+ end,+ sha256: sha256_hex(&body.as_bytes()[*start..end]),+ });+ }+ sections+}++fn heading_positions(body: &str) -> Vec<(usize, usize, String)> {+ let mut out = Vec::new();+ let mut offset = 0;+ let mut in_fence = false;+ for line in body.split_inclusive('\n') {+ let trimmed = line.trim_end_matches(['\r', '\n']);+ if is_fence_line(trimmed) {+ in_fence = !in_fence;+ } else if !in_fence && let Some(level) = heading_level(trimmed) {+ out.push((offset, level, trimmed.to_string()));+ }+ offset += line.len();+ }+ out+}++fn is_fence_line(line: &str) -> bool {+ let trimmed = line.trim_start();+ trimmed.starts_with("```") || trimmed.starts_with("~~~")+}++fn heading_level(line: &str) -> Option<usize> {+ let hashes = line.chars().take_while(|c| *c == '#').count();+ if (1..=6).contains(&hashes) && line.as_bytes().get(hashes) == Some(&b' ') {+ Some(hashes)+ } else {+ None+ }+}++fn sha256_hex(bytes: &[u8]) -> String {+ let mut hasher = Sha256::new();+ hasher.update(bytes);+ let digest = hasher.finalize();+ digest.iter().map(|b| format!("{b:02x}")).collect()+}+fn truncate_with_marker(input: &str, max_bytes: usize, marker: &str) -> (String, bool) {if input.len() <= max_bytes {return (input.to_string(), false);@@ -489,6 +1289,37 @@ fn truncate_with_marker(input: &str, max_bytes: usize, marker: &str) -> (String,(out, true)}+fn truncate_to_budget(input: &str, max_bytes: usize, marker: &str) -> String {+ if input.len() <= max_bytes {+ return input.to_string();+ }+ if max_bytes == 0 {+ return String::new();+ }++ let marker_start = if marker.len() < max_bytes {+ max_bytes - marker.len()+ } else {+ 0+ };+ let mut end = marker_start.min(input.len());+ while end > 0 && !input.is_char_boundary(end) {+ end -= 1;+ }++ let mut out = input[..end].to_string();+ if out.len() + marker.len() <= max_bytes {+ out.push_str(marker);+ } else {+ let mut marker_end = max_bytes.saturating_sub(out.len()).min(marker.len());+ while marker_end > 0 && !marker.is_char_boundary(marker_end) {+ marker_end -= 1;+ }+ out.push_str(&marker[..marker_end]);+ }+ out+}+fn preflight_rejection(observations: &[Observation],duration_secs: u64,@@ -502,6 +1333,10 @@ fn preflight_rejection(observations.len(),cfg.min_observations),+ target_path: None,+ kind: None,+ operation: None,+ edit_mode: None,});}if duration_secs < cfg.min_session_duration_secs {@@ -511,6 +1346,10 @@ fn preflight_rejection("{duration_secs}s below configured minimum {}s",cfg.min_session_duration_secs),+ target_path: None,+ kind: None,+ operation: None,+ edit_mode: None,});}None@@ -528,21 +1367,47 @@ fn validate_response(let mut proposals = Vec::new();let mut rejected = raw.rejected_candidates;let mut warnings = Vec::new();+ let mut patch_edits_used = 0usize;for mut proposal in raw.proposals {if proposals.len() >= cfg.max_proposals_per_run {rejected.push(AutoImproveRejectedCandidate {reason: "max_proposals_exceeded".into(),- evidence: proposal.path,+ evidence: proposal.path.clone(),+ target_path: Some(proposal.path),+ kind: Some(proposal.kind),+ operation: Some(proposal.operation),+ edit_mode: Some(proposal.edit_mode),});continue;}normalize_proposal(&mut proposal, &mut warnings);- match validate_proposal(&proposal, cfg, existing_index) {- Ok(()) => proposals.push(proposal),+ match validate_proposal(&mut proposal, cfg, existing_index) {+ Ok(()) => {+ if proposal.edit_mode == "patch" {+ let edit_count = proposal.edits.len();+ if patch_edits_used.saturating_add(edit_count) > cfg.max_patch_edits_per_run {+ rejected.push(AutoImproveRejectedCandidate {+ reason: "patch_run_edit_budget_exceeded".into(),+ evidence: proposal.path.clone(),+ target_path: Some(proposal.path),+ kind: Some(proposal.kind),+ operation: Some(proposal.operation),+ edit_mode: Some(proposal.edit_mode),+ });+ continue;+ }+ patch_edits_used += edit_count;+ }+ proposals.push(proposal);+ }Err(reason) => rejected.push(AutoImproveRejectedCandidate {reason,- evidence: proposal.path,+ evidence: proposal.path.clone(),+ target_path: Some(proposal.path),+ kind: Some(proposal.kind),+ operation: Some(proposal.operation),+ edit_mode: Some(proposal.edit_mode),}),}}@@ -557,6 +1422,13 @@ fn validate_response(fn normalize_proposal(proposal: &mut AutoImproveProposal, warnings: &mut Vec<String>) {normalize_kind(proposal, warnings);+ if proposal.edit_mode.trim().is_empty() {+ proposal.edit_mode = default_edit_mode();+ }+ if proposal.edit_mode == "patch" {+ return;+ }+if proposal.body_markdown.trim_start().starts_with("# ") {return;}@@ -626,7 +1498,7 @@ fn canonical_kind_for_path(path: &str) -> Option<&'static str> {}fn validate_proposal(- proposal: &AutoImproveProposal,+ proposal: &mut AutoImproveProposal,cfg: &AutoImproveReviewConfig,existing_index: &ExistingPageIndex,) -> Result<(), String> {@@ -647,58 +1519,261 @@ fn validate_proposal({return Err("missing_evidence".into());}+ let path = PagePath::new(proposal.path.clone()).map_err(|_| "invalid_path".to_string())?;+ match proposal.edit_mode.as_str() {+ "" | "full_page" => {+ validate_full_page_proposal(proposal, cfg, existing_index, path.as_str())+ }+ "patch" => validate_patch_proposal(proposal, cfg, existing_index, path.as_str()),+ _ => Err("unsupported_edit_mode".into()),+ }+}++fn validate_full_page_proposal(+ proposal: &AutoImproveProposal,+ cfg: &AutoImproveReviewConfig,+ existing_index: &ExistingPageIndex,+ path: &str,+) -> Result<(), String> {if proposal.body_markdown.trim().is_empty() {return Err("empty_body".into());}- if proposal.body_markdown.len() > MAX_PROPOSAL_BODY_CHARS {+ if proposal.body_markdown.len() > cfg.max_final_body_chars.min(MAX_PROPOSAL_BODY_CHARS) {return Err("body_too_large".into());}+ enforce_page_budget(path, &proposal.body_markdown, cfg)?;if !proposal.body_markdown.trim_start().starts_with("# ") {return Err("body_missing_h1".into());}- let path = PagePath::new(proposal.path.clone()).map_err(|_| "invalid_path".to_string())?;- if !allowed_target_path(path.as_str()) {+ if !allowed_target_path(path) {return Err("unsupported_path_prefix".into());}- if path.as_str() != "_slots/current-focus.md" && existing_index.contains_path(path.as_str()) {+ if path != "_slots/current-focus.md" && existing_index.contains_path(path) {return Err("duplicate_existing_path".into());}- if path.as_str() != "_slots/current-focus.md" && existing_index.contains_title(&proposal.title)- {+ if path != "_slots/current-focus.md" && existing_index.contains_title(&proposal.title) {return Err("duplicate_existing_title".into());}- if !kind_matches_path(&proposal.kind, path.as_str()) {+ if !kind_matches_path(&proposal.kind, path) {return Err("kind_path_mismatch".into());}Ok(())}-fn allowed_target_path(path: &str) -> bool {- path.starts_with("gotchas/")- || path.starts_with("decisions/")- || path.starts_with("concepts/")- || path.starts_with("procedures/")- || path.starts_with("_rules/")- || path.starts_with("notes/")- || path == "_slots/current-focus.md"-}--fn kind_matches_path(kind: &str, path: &str) -> bool {- match kind {- "gotcha" => path.starts_with("gotchas/"),- "decision" => path.starts_with("decisions/"),- "concept" => path.starts_with("concepts/"),- "procedure" => path.starts_with("procedures/"),- "rule" => path.starts_with("_rules/"),- "slot" => path.starts_with("_slots/"),- "fact" | "note" => path.starts_with("notes/") || path.starts_with("concepts/"),- _ => false,+fn validate_patch_proposal(+ proposal: &mut AutoImproveProposal,+ cfg: &AutoImproveReviewConfig,+ existing_index: &ExistingPageIndex,+ path: &str,+) -> Result<(), String> {+ if !(path.starts_with("_rules/") || path.starts_with("procedures/")) {+ return Err("patch_unsupported_path".into());}-}--fn session_duration_secs(observations: &[Observation]) -> u64 {- let (Some(first), Some(last)) = (observations.first(), observations.last()) else {- return 0;+ let Some(target) = existing_index.patchable(path) else {+ return Err("patch_target_not_in_context".into());+ };+ if proposal.edits.is_empty() {+ return Err("patch_missing_edits".into());+ }+ if proposal.edits.len() > cfg.max_edits_per_proposal {+ return Err("patch_too_many_edits".into());+ }+ let changed_chars: usize = proposal.edits.iter().map(|e| e.content.len()).sum();+ if changed_chars > cfg.max_changed_chars_per_proposal {+ return Err("patch_changed_chars_too_large".into());+ }+ if proposal+ .edits+ .iter()+ .any(|e| e.content.len() > cfg.max_edit_content_chars)+ {+ return Err("patch_edit_content_too_large".into());+ }+ if has_duplicate_headings(&target.body) {+ return Err("duplicate_anchor".into());+ }+ let body = materialize_patch(&target.body, &proposal.edits)?;+ if body.len() > cfg.max_final_body_chars.min(MAX_PROPOSAL_BODY_CHARS) {+ return Err("body_too_large".into());+ }+ enforce_page_budget(path, &body, cfg)?;+ if !body.trim_start().starts_with("# ") {+ return Err("body_missing_h1".into());+ }+ if h1_count(&body) != 1 {+ return Err("patch_extra_h1".into());+ }+ if has_duplicate_headings(&body) {+ return Err("duplicate_anchor".into());+ }+ if !kind_matches_path(&proposal.kind, path) {+ return Err("kind_path_mismatch".into());+ }+ proposal.body_markdown = body;+ proposal.expected_base_body_sha256 = Some(target.body_sha256.clone());+ Ok(())+}++fn enforce_page_budget(+ path: &str,+ body: &str,+ cfg: &AutoImproveReviewConfig,+) -> Result<(), String> {+ if path.starts_with("_rules/") {+ let max_chars = cfg.max_rule_page_tokens.saturating_mul(CHARS_PER_TOKEN);+ if body.len() > max_chars {+ return Err("rule_page_budget_exceeded".into());+ }+ } else if path.starts_with("procedures/") {+ let max_chars = cfg+ .max_procedure_page_tokens+ .saturating_mul(CHARS_PER_TOKEN);+ if body.len() > max_chars {+ return Err("procedure_page_budget_exceeded".into());+ }+ }+ Ok(())+}++fn materialize_patch(body: &str, edits: &[AutoImprovePatchEdit]) -> Result<String, String> {+ let mut current = body.to_string();+ for edit in edits {+ if edit.op == "delete_section" {+ return Err("unsupported_patch_op".into());+ }+ let sections = parse_markdown_sections(¤t);+ if duplicate_heading_count(§ions, &edit.anchor) > 1 {+ return Err("duplicate_anchor".into());+ }+ let section = sections+ .iter()+ .find(|section| section.anchor == edit.anchor)+ .ok_or_else(|| "patch_anchor_not_found".to_string())?;+ let section_level = section.level;+ let section_start = section.start;+ let section_end = section.end;+ if section.level == 1 {+ return Err("patch_h1_anchor_unsupported".into());+ }+ match edit.op.as_str() {+ "append" => {+ let insert =+ bounded_markdown_block(&edit.content, true, section_end < current.len());+ current.insert_str(section_end, &insert);+ }+ "add_section" => {+ let inserted_level = first_heading_level(&edit.content)+ .ok_or_else(|| "add_section_missing_heading".to_string())?;+ if inserted_level == 1 {+ return Err("add_section_h1_unsupported".into());+ }+ if inserted_level != section_level {+ return Err("add_section_heading_level_mismatch".into());+ }+ let insert =+ bounded_markdown_block(&edit.content, true, section_end < current.len());+ current.insert_str(section_end, &insert);+ }+ "replace_section" => {+ let expected = edit+ .section_sha256+ .as_deref()+ .ok_or_else(|| "replace_section_missing_hash".to_string())?;+ if expected != section.sha256 {+ return Err("replace_section_hash_mismatch".into());+ }+ let replacement_anchor = first_nonblank_line(&edit.content)+ .ok_or_else(|| "replace_section_missing_heading".to_string())?;+ if replacement_anchor != edit.anchor {+ return Err("replace_section_anchor_mismatch".into());+ }+ let replacement =+ bounded_markdown_block(&edit.content, false, section_end < current.len());+ current.replace_range(+ section_start..section_end,+ replacement.trim_start_matches('\n'),+ );+ }+ _ => return Err("unsupported_patch_op".into()),+ }+ }+ Ok(current)+}++fn bounded_markdown_block(content: &str, prefix_blank: bool, suffix_blank: bool) -> String {+ let mut out = String::new();+ if prefix_blank {+ out.push_str("\n\n");+ }+ out.push_str(content.trim());+ if suffix_blank {+ out.push_str("\n\n");+ } else {+ out.push('\n');+ }+ out+}++fn first_heading_level(content: &str) -> Option<usize> {+ first_nonblank_line(content).and_then(heading_level)+}++fn first_nonblank_line(content: &str) -> Option<&str> {+ content+ .lines()+ .map(|line| line.trim_end_matches('\r'))+ .find(|line| !line.trim().is_empty())+}++fn has_duplicate_headings(body: &str) -> bool {+ let mut seen = BTreeSet::new();+ parse_markdown_sections(body)+ .into_iter()+ .map(|section| normalize_title(§ion.anchor))+ .any(|anchor| !seen.insert(anchor))+}++fn duplicate_heading_count(sections: &[MarkdownSection], anchor: &str) -> usize {+ let normalized = normalize_title(anchor);+ sections+ .iter()+ .filter(|section| normalize_title(§ion.anchor) == normalized)+ .count()+}++fn h1_count(body: &str) -> usize {+ parse_markdown_sections(body)+ .into_iter()+ .filter(|section| section.level == 1)+ .count()+}++fn allowed_target_path(path: &str) -> bool {+ path.starts_with("gotchas/")+ || path.starts_with("decisions/")+ || path.starts_with("concepts/")+ || path.starts_with("procedures/")+ || path.starts_with("_rules/")+ || path.starts_with("notes/")+ || path == "_slots/current-focus.md"+}++fn kind_matches_path(kind: &str, path: &str) -> bool {+ match kind {+ "gotcha" => path.starts_with("gotchas/"),+ "decision" => path.starts_with("decisions/"),+ "concept" => path.starts_with("concepts/"),+ "procedure" => path.starts_with("procedures/"),+ "rule" => path.starts_with("_rules/"),+ "slot" => path.starts_with("_slots/"),+ "fact" | "note" => path.starts_with("notes/") || path.starts_with("concepts/"),+ _ => false,+ }+}++fn session_duration_secs(observations: &[Observation]) -> u64 {+ let (Some(first), Some(last)) = (observations.first(), observations.last()) else {+ return 0;};let diff_us = last.created_at@@ -725,7 +1800,7 @@ Only propose durable, future-useful knowledge:Reject transient setup failures, smoke tests, release markers, one-off task narratives, broad negative tool claims, and failures that were resolved without a reusable lesson.-Every proposal must include bounded evidence quotes, confidence, rationale, a valid path, and markdown beginning with an H1. Rule paths must start with `_rules/`, not `rules/`. Do not target sessions/ or _pending/. Treat the consolidated session page as primary when present; selected observations are supporting context. Do not promote ai-memory routing snippets, AGENTS.md/CLAUDE.md instructions, or generic agent tool guidance unless the session explicitly changed project policy."#;+Every proposal must include bounded evidence quotes, confidence, rationale, and a valid path. Full-page proposals must include markdown beginning with an H1; patch proposals must include anchored edits and are materialized before staging. Rule paths must start with `_rules/`, not `rules/`. Do not target sessions/ or _pending/. Treat the consolidated session page as primary when present; selected observations are supporting context. Do not promote ai-memory routing snippets, AGENTS.md/CLAUDE.md instructions, or generic agent tool guidance unless the session explicitly changed project policy."#;#[cfg(test)]mod tests {@@ -788,6 +1863,18 @@ mod tests {include_raw_fallback: false,proposal_actor: "auto_improve".into(),pending_path: "_pending/auto-improve".into(),+ max_patchable_pages: DEFAULT_AUTO_IMPROVE_MAX_PATCHABLE_PAGES,+ max_patchable_body_chars: DEFAULT_AUTO_IMPROVE_MAX_PATCHABLE_BODY_CHARS,+ max_edits_per_proposal: DEFAULT_AUTO_IMPROVE_MAX_EDITS_PER_PROPOSAL,+ max_edit_content_chars: DEFAULT_AUTO_IMPROVE_MAX_EDIT_CONTENT_CHARS,+ max_changed_chars_per_proposal: DEFAULT_AUTO_IMPROVE_MAX_CHANGED_CHARS_PER_PROPOSAL,+ max_patch_edits_per_run: DEFAULT_AUTO_IMPROVE_MAX_PATCH_EDITS_PER_RUN,+ max_rejection_context: DEFAULT_AUTO_IMPROVE_MAX_REJECTION_CONTEXT,+ rejection_context_days: DEFAULT_AUTO_IMPROVE_REJECTION_CONTEXT_DAYS,+ max_final_body_chars: DEFAULT_AUTO_IMPROVE_MAX_FINAL_BODY_CHARS,+ max_rule_page_tokens: DEFAULT_AUTO_IMPROVE_MAX_RULE_PAGE_TOKENS,+ max_procedure_page_tokens: DEFAULT_AUTO_IMPROVE_MAX_PROCEDURE_PAGE_TOKENS,+ eval: AutoImproveEvalConfig::default(),}}@@ -804,9 +1891,217 @@ mod tests {quote: "quote".into(),}],body_markdown: "# Test\n\nBody".into(),+ edit_mode: default_edit_mode(),+ edits: Vec::new(),+ expected_base_body_sha256: None,}}+ fn eval_cfg(command: String) -> AutoImproveEvalConfig {+ AutoImproveEvalConfig {+ enabled: true,+ command,+ timeout_secs: 2,+ targets: default_auto_improve_eval_targets(),+ min_delta: 0.01,+ }+ }++ fn write_eval_script(body: &str) -> String {+ use std::os::unix::fs::PermissionsExt;+ let dir = tempfile::TempDir::new().unwrap().keep();+ let path = dir.join("eval.sh");+ std::fs::write(&path, body).unwrap();+ let mut perms = std::fs::metadata(&path).unwrap().permissions();+ perms.set_mode(0o755);+ std::fs::set_permissions(&path, perms).unwrap();+ path.display().to_string()+ }++ #[tokio::test]+ async fn eval_disabled_preserves_current_behavior() {+ let mut proposals = vec![proposal("_rules/test.md", "rule", 0.9)];+ let mut rejected = Vec::new();+ let mut warnings = Vec::new();+ apply_eval_gate_with_before_bodies(+ &AutoImproveEvalConfig::default(),+ &mut proposals,+ &mut rejected,+ &mut warnings,+ &BTreeMap::new(),+ )+ .await;+ assert_eq!(proposals.len(), 1);+ assert!(rejected.is_empty());+ assert!(warnings.is_empty());+ }++ #[tokio::test]+ async fn passing_eval_allows_proposal_and_records_evidence() {+ let script = write_eval_script(+ "#!/bin/sh\ncat >/dev/null\nprintf '%s' '{\"score_before\":0.72,\"score_after\":0.76,\"passed\":true}'\n",+ );+ let mut proposals = vec![proposal("_rules/test.md", "rule", 0.9)];+ let mut rejected = Vec::new();+ let mut warnings = Vec::new();+ apply_eval_gate_with_before_bodies(+ &eval_cfg(script),+ &mut proposals,+ &mut rejected,+ &mut warnings,+ &BTreeMap::new(),+ )+ .await;+ assert_eq!(proposals.len(), 1);+ assert!(+ proposals[0]+ .evidence+ .iter()+ .any(|e| e.page == "auto_improve_eval")+ );+ assert!(rejected.is_empty());+ }++ #[tokio::test]+ async fn failing_eval_filters_and_records_rejection() {+ let script = write_eval_script(+ "#!/bin/sh\ncat >/dev/null\nprintf '%s' '{\"score_before\":0.72,\"score_after\":0.70,\"passed\":true}'\n",+ );+ let mut proposals = vec![proposal("procedures/test.md", "procedure", 0.9)];+ let mut rejected = Vec::new();+ let mut warnings = Vec::new();+ apply_eval_gate_with_before_bodies(+ &eval_cfg(script),+ &mut proposals,+ &mut rejected,+ &mut warnings,+ &BTreeMap::new(),+ )+ .await;+ assert!(proposals.is_empty());+ assert_eq!(rejected.len(), 1);+ assert_eq!(rejected[0].reason, "eval_gate_failed");+ assert_eq!(+ rejected[0].target_path.as_deref(),+ Some("procedures/test.md")+ );+ }++ #[tokio::test]+ async fn eval_error_timeout_and_invalid_json_fail_closed() {+ let cases = vec![+ (+ write_eval_script("#!/bin/sh\ncat >/dev/null\nexit 7\n"),+ "eval_gate_error",+ ),+ (+ write_eval_script("#!/bin/sh\ncat >/dev/null\nprintf 'not-json'\n"),+ "eval_gate_error",+ ),+ (+ write_eval_script("#!/bin/sh\ncat >/dev/null\nsleep 3\n"),+ "eval_gate_timeout",+ ),+ ];+ for (command, expected_reason) in cases {+ let mut cfg = eval_cfg(command);+ cfg.timeout_secs = 1;+ let mut proposals = vec![proposal("_rules/test.md", "rule", 0.9)];+ let mut rejected = Vec::new();+ let mut warnings = Vec::new();+ apply_eval_gate_with_before_bodies(+ &cfg,+ &mut proposals,+ &mut rejected,+ &mut warnings,+ &BTreeMap::new(),+ )+ .await;+ assert!(proposals.is_empty());+ assert_eq!(rejected[0].reason, expected_reason);+ }+ }++ #[tokio::test]+ async fn eval_timeout_covers_blocked_stdin_write() {+ let script = write_eval_script("#!/bin/sh\nsleep 5\n");+ let mut cfg = eval_cfg(script);+ cfg.timeout_secs = 1;+ let mut proposal = proposal("_rules/test.md", "rule", 0.9);+ proposal.body_markdown = "x".repeat(10 * 1024 * 1024);+ let mut proposals = vec![proposal];+ let mut rejected = Vec::new();+ let mut warnings = Vec::new();++ let started = std::time::Instant::now();+ apply_eval_gate_with_before_bodies(+ &cfg,+ &mut proposals,+ &mut rejected,+ &mut warnings,+ &BTreeMap::new(),+ )+ .await;++ assert!(proposals.is_empty());+ assert_eq!(rejected[0].reason, "eval_gate_timeout");+ assert!(started.elapsed() < Duration::from_secs(3));+ }++ #[tokio::test]+ async fn oversized_eval_stdout_fails_closed() {+ let script = write_eval_script(+ "#!/bin/sh\ni=0\nwhile [ $i -lt 70000 ]; do printf x; i=$((i + 1)); done\n",+ );+ let mut proposals = vec![proposal("_rules/test.md", "rule", 0.9)];+ let mut rejected = Vec::new();+ let mut warnings = Vec::new();+ apply_eval_gate_with_before_bodies(+ &eval_cfg(script),+ &mut proposals,+ &mut rejected,+ &mut warnings,+ &BTreeMap::new(),+ )+ .await;++ assert!(proposals.is_empty());+ assert_eq!(rejected[0].reason, "eval_gate_error");+ assert!(rejected[0].evidence.contains("eval stdout exceeded"));+ }++ #[test]+ fn oversized_eval_reason_is_capped_before_rejection_evidence() {+ let outcome = AutoImproveEvalResponse {+ score_before: None,+ score_after: None,+ passed: false,+ reason: Some("a".repeat(MAX_EVAL_REASON_CHARS + 100)),+ };+ let evidence = format_eval_failure(&outcome, None, 0.0);++ assert!(evidence.contains("eval reason truncated"));+ assert!(evidence.len() < MAX_EVAL_REASON_CHARS + 200);+ }++ #[tokio::test]+ async fn non_targeted_proposal_bypasses_eval() {+ let script = write_eval_script("#!/bin/sh\nexit 7\n");+ let mut proposals = vec![proposal("gotchas/test.md", "gotcha", 0.9)];+ let mut rejected = Vec::new();+ let mut warnings = Vec::new();+ apply_eval_gate_with_before_bodies(+ &eval_cfg(script),+ &mut proposals,+ &mut rejected,+ &mut warnings,+ &BTreeMap::new(),+ )+ .await;+ assert_eq!(proposals.len(), 1);+ assert!(rejected.is_empty());+ }+fn obs(idx: usize,kind: ObservationKind,@@ -1104,6 +2399,8 @@ mod tests {3_600,Some(&page),&[],+ &[],+ &[],&AutoImproveReviewConfig {max_input_tokens: 8_000,..cfg()@@ -1121,6 +2418,179 @@ mod tests {);}+ #[test]+ fn prompt_bounds_patchable_context_and_charges_observation_budget() {+ let session_id = SessionId::new();+ let observations: Vec<_> = (0..20)+ .map(|i| {+ obs(+ i,+ ObservationKind::PostToolUse,+ &format!("obs {i}"),+ "important reusable detail ".repeat(80).as_str(),+ 8,+ )+ })+ .collect();+ let body = format!("# Rule\n\n## Anchor\n{}", "body ".repeat(2_000));+ let patchable = vec![PatchablePageContext {+ path: "_rules/test.md".into(),+ title: "Test rule".into(),+ kind: "rule".into(),+ body_sha256: sha256_hex(body.as_bytes()),+ sections: parse_markdown_sections(&body),+ body,+ }];+ let prompt = build_prompt_input(+ session_id,+ &observations,+ 3_600,+ None,+ &[],+ &patchable,+ &[],+ &AutoImproveReviewConfig {+ max_input_tokens: 2_500,+ max_patchable_body_chars: 512,+ ..cfg()+ },+ );++ assert!(prompt.prompt.contains("[patchable target body truncated]"));+ assert!(+ prompt+ .warnings+ .iter()+ .any(|w| w.contains("patchable target _rules/test.md body truncated"))+ );+ assert!(+ prompt+ .rejected_candidates+ .iter()+ .any(|r| r.reason == "input_budget_sampled")+ );+ }++ #[test]+ fn prompt_includes_rejection_context() {+ let session_id = SessionId::new();+ let observations = vec![obs(+ 1,+ ObservationKind::PostToolUse,+ "durable",+ "avoid repeating failed auto-improve edits",+ 10,+ )];+ let rejections = vec![AutoImproveRejectionSummary {+ id: "r1".into(),+ workspace_id: WorkspaceId::new(),+ project_id: ProjectId::new(),+ target_path: Some("notes/repeat.md".into()),+ kind: Some("note".into()),+ operation: Some("create".into()),+ edit_mode: Some("full_page".into()),+ reason: "duplicate_existing_path".into(),+ normalized_fingerprint: "abc123".into(),+ summary: "Repeated note".into(),+ evidence_json: serde_json::json!({}),+ source_run_id: None,+ source_proposal_id: None,+ created_at: 1,+ }];++ let prompt = build_prompt_input(+ session_id,+ &observations,+ 3_600,+ None,+ &[],+ &[],+ &rejections,+ &cfg(),+ );++ assert!(+ prompt+ .prompt+ .contains("Recent rejected auto-improvement attempts")+ );+ assert!(prompt.prompt.contains("notes/repeat.md"));+ assert!(prompt.prompt.contains("duplicate_existing_path"));+ assert!(prompt.prompt.contains("abc123"));+ }++ #[test]+ fn prompt_bounds_rejection_context_and_charges_observation_budget() {+ let session_id = SessionId::new();+ let observations: Vec<_> = (0..80)+ .map(|i| {+ obs(+ i,+ ObservationKind::PostToolUse,+ &format!("obs {i}"),+ "important bounded observation detail ".repeat(120).as_str(),+ 8,+ )+ })+ .collect();+ let rejections: Vec<_> = (0..20)+ .map(|i| AutoImproveRejectionSummary {+ id: format!("r{i}"),+ workspace_id: WorkspaceId::new(),+ project_id: ProjectId::new(),+ target_path: Some(format!("notes/{}repeat.md", "p".repeat(500))),+ kind: Some("note".into()),+ operation: Some("create".into()),+ edit_mode: Some("full_page".into()),+ reason: format!("duplicate_existing_path {}", "reason ".repeat(1_000)),+ normalized_fingerprint: "abcdef".repeat(80),+ summary: format!("Repeated oversized note {i}: {}", "summary ".repeat(2_000)),+ evidence_json: serde_json::json!({}),+ source_run_id: None,+ source_proposal_id: None,+ created_at: i,+ })+ .collect();+ let cfg = AutoImproveReviewConfig {+ max_input_tokens: 2_500,+ ..cfg()+ };++ let prompt = build_prompt_input(+ session_id,+ &observations,+ 3_600,+ None,+ &[],+ &[],+ &rejections,+ &cfg,+ );++ let usable_chars = cfg+ .max_input_tokens+ .saturating_sub(PROMPT_RESERVE_TOKENS)+ .saturating_mul(CHARS_PER_TOKEN);+ let rejection_section = prompt+ .prompt+ .split("Recent rejected auto-improvement attempts for this workspace/project. Avoid repeating these target/reason/fingerprint patterns unless the session provides clearly new evidence:\n")+ .nth(1)+ .and_then(|rest| rest.split("\n\nConsolidated session page").next())+ .expect("prompt includes rejection section");+ assert!(rejection_section.len() <= rejection_context_char_budget(usable_chars));+ assert!(rejection_section.contains("[truncated]"));+ assert!(rejection_section.contains("[rejection context truncated]"));+ assert!(!prompt.prompt.contains(&"summary ".repeat(500)));+ assert!(prompt.prompt.contains("Selected observations"));+ assert!(+ prompt+ .rejected_candidates+ .iter()+ .any(|r| r.reason == "input_budget_sampled")+ );+ assert!(prompt.warnings.iter().any(|w| w.contains("sampled")));+ }+#[test]fn validation_prepends_title_when_body_is_missing_h1() {let mut candidate = proposal("gotchas/missing-h1.md", "gotcha", 0.91);@@ -1141,12 +2611,15 @@ mod tests {#[test]fn validation_rejects_existing_path_duplicates() {- let existing = ExistingPageIndex::from_pages(&[BriefingPage {- path: "gotchas/existing.md".into(),- title: "Existing Lesson".into(),- kind: "gotcha".into(),- updated_at: "2026-06-15T00:00:00Z".into(),- }]);+ let existing = ExistingPageIndex::from_pages(+ &[BriefingPage {+ path: "gotchas/existing.md".into(),+ title: "Existing Lesson".into(),+ kind: "gotcha".into(),+ updated_at: "2026-06-15T00:00:00Z".into(),+ }],+ &[],+ );let raw = AutoImproveLlmResponse {summary: "ok".into(),proposals: vec![@@ -1201,4 +2674,489 @@ mod tests {assert_eq!(rejected.len(), 1);assert_eq!(rejected[0].reason, "max_proposals_exceeded");}++ #[test]+ fn patch_run_edit_budget_rejects_later_patches_only() {+ let body = "# Release\n\n## Steps\nOne\n";+ let mut first = patch_proposal("append", "## Steps", "Two");+ first.path = "procedures/release.md".into();+ let mut second = patch_proposal("append", "## Steps", "Three");+ second.path = "procedures/release.md".into();+ let raw = AutoImproveLlmResponse {+ summary: "ok".into(),+ proposals: vec![first, second],+ rejected_candidates: Vec::new(),+ };+ let review_cfg = AutoImproveReviewConfig {+ max_patch_edits_per_run: 1,+ max_proposals_per_run: 3,+ ..cfg()+ };++ let (accepted, rejected, _) = validate_response(+ raw,+ &review_cfg,+ &patch_index("procedures/release.md", body),+ );+ assert_eq!(accepted.len(), 1);+ assert!(accepted[0].body_markdown.contains("Two"));+ assert_eq!(rejected.len(), 1);+ assert_eq!(rejected[0].reason, "patch_run_edit_budget_exceeded");+ }++ #[test]+ fn rule_and_procedure_full_page_budgets_reject_only_targeted_kinds() {+ let mut rule = proposal("_rules/small.md", "rule", 0.91);+ rule.body_markdown = "# Small\n\nThis rule is too long for one token.".into();+ let mut procedure = proposal("procedures/small.md", "procedure", 0.91);+ procedure.body_markdown = "# Small\n\nThis procedure is too long for one token.".into();+ let mut gotcha = proposal("gotchas/unchanged.md", "gotcha", 0.91);+ gotcha.body_markdown = "# Small\n\nThis gotcha may exceed scoped page budgets.".into();+ let raw = AutoImproveLlmResponse {+ summary: "ok".into(),+ proposals: vec![rule, procedure, gotcha],+ rejected_candidates: Vec::new(),+ };+ let review_cfg = AutoImproveReviewConfig {+ max_proposals_per_run: 3,+ max_rule_page_tokens: 1,+ max_procedure_page_tokens: 1,+ ..cfg()+ };++ let (accepted, rejected, _) =+ validate_response(raw, &review_cfg, &ExistingPageIndex::default());+ assert_eq!(accepted.len(), 1);+ assert_eq!(accepted[0].path, "gotchas/unchanged.md");+ assert_eq!(rejected.len(), 2);+ assert_eq!(rejected[0].reason, "rule_page_budget_exceeded");+ assert_eq!(rejected[1].reason, "procedure_page_budget_exceeded");+ }++ #[test]+ fn rule_and_procedure_patch_materialized_bodies_obey_page_budgets() {+ let rule_body = "# Rule\n\n## Details\nShort\n";+ let procedure_body = "# Procedure\n\n## Steps\nShort\n";+ let mut rule_patch =+ patch_proposal("append", "## Details", "This makes the rule too long.");+ rule_patch.path = "_rules/small.md".into();+ rule_patch.kind = "rule".into();+ let mut procedure_patch =+ patch_proposal("append", "## Steps", "This makes the procedure too long.");+ procedure_patch.path = "procedures/small.md".into();+ let raw_rule = AutoImproveLlmResponse {+ summary: "ok".into(),+ proposals: vec![rule_patch],+ rejected_candidates: Vec::new(),+ };+ let raw_procedure = AutoImproveLlmResponse {+ summary: "ok".into(),+ proposals: vec![procedure_patch],+ rejected_candidates: Vec::new(),+ };+ let review_cfg = AutoImproveReviewConfig {+ max_rule_page_tokens: 2,+ max_procedure_page_tokens: 2,+ ..cfg()+ };++ let (accepted, rejected, _) = validate_response(+ raw_rule,+ &review_cfg,+ &patch_index("_rules/small.md", rule_body),+ );+ assert!(accepted.is_empty());+ assert_eq!(rejected[0].reason, "rule_page_budget_exceeded");++ let (accepted, rejected, _) = validate_response(+ raw_procedure,+ &review_cfg,+ &patch_index("procedures/small.md", procedure_body),+ );+ assert!(accepted.is_empty());+ assert_eq!(rejected[0].reason, "procedure_page_budget_exceeded");+ }++ fn patch_index(path: &str, body: &str) -> ExistingPageIndex {+ let kind = if path.starts_with("_rules/") {+ "rule"+ } else {+ "procedure"+ };+ ExistingPageIndex::from_pages(+ &[BriefingPage {+ path: path.into(),+ title: "Patch Target".into(),+ kind: kind.into(),+ updated_at: "2026-06-15T00:00:00Z".into(),+ }],+ &[patchable_context(path, "Patch Target", kind, body)],+ )+ }++ fn patchable_context(path: &str, title: &str, kind: &str, body: &str) -> PatchablePageContext {+ PatchablePageContext {+ path: path.into(),+ title: title.into(),+ kind: kind.into(),+ body: body.into(),+ body_sha256: sha256_hex(body.as_bytes()),+ sections: parse_markdown_sections(body),+ }+ }++ fn patch_proposal(op: &str, anchor: &str, content: &str) -> AutoImproveProposal {+ AutoImproveProposal {+ edit_mode: "patch".into(),+ edits: vec![AutoImprovePatchEdit {+ op: op.into(),+ anchor: anchor.into(),+ content: content.into(),+ section_sha256: None,+ context: None,+ }],+ body_markdown: String::new(),+ ..proposal("procedures/release.md", "procedure", 0.91)+ }+ }++ #[test]+ fn patch_to_missing_or_non_context_target_rejects() {+ let raw = AutoImproveLlmResponse {+ summary: "ok".into(),+ proposals: vec![patch_proposal("append", "## Steps", "More")],+ rejected_candidates: Vec::new(),+ };+ let (accepted, rejected, _) = validate_response(raw, &cfg(), &ExistingPageIndex::default());+ assert!(accepted.is_empty());+ assert_eq!(rejected[0].reason, "patch_target_not_in_context");+ }++ #[test]+ fn patch_omitted_by_patchable_budget_rejects() {+ let included_body = "# Included\n\n## Steps\nOne\n";+ let omitted_body = "# Omitted\n\n## Steps\nOne\n";+ let included = patchable_context(+ "procedures/included.md",+ "Included",+ "procedure",+ included_body,+ );+ let omitted = patchable_context(+ "procedures/omitted.md",+ "Omitted",+ "procedure",+ omitted_body,+ );+ let mut warnings = Vec::new();+ let first_only = render_patchable_pages(+ std::slice::from_ref(&included),+ usize::MAX,+ usize::MAX,+ &mut warnings,+ );+ let rendered = render_patchable_pages(+ &[included.clone(), omitted.clone()],+ usize::MAX,+ first_only.text.len(),+ &mut warnings,+ );+ assert!(rendered.included_paths.contains("procedures/included.md"));+ assert!(!rendered.included_paths.contains("procedures/omitted.md"));++ let recent = [+ BriefingPage {+ path: "procedures/included.md".into(),+ title: "Included".into(),+ kind: "procedure".into(),+ updated_at: "2026-06-15T00:00:00Z".into(),+ },+ BriefingPage {+ path: "procedures/omitted.md".into(),+ title: "Omitted".into(),+ kind: "procedure".into(),+ updated_at: "2026-06-15T00:00:00Z".into(),+ },+ ];+ let prompt_patchable: Vec<_> = [included, omitted]+ .into_iter()+ .filter(|page| rendered.included_paths.contains(&page.path))+ .collect();+ let index = ExistingPageIndex::from_pages(&recent, &prompt_patchable);+ let mut candidate = patch_proposal("append", "## Steps", "More");+ candidate.path = "procedures/omitted.md".into();+ let raw = AutoImproveLlmResponse {+ summary: "ok".into(),+ proposals: vec![candidate],+ rejected_candidates: Vec::new(),+ };++ let (accepted, rejected, _) = validate_response(raw, &cfg(), &index);+ assert!(accepted.is_empty());+ assert_eq!(rejected[0].reason, "patch_target_not_in_context");+ }++ #[test]+ fn max_patchable_pages_zero_rejects_patch_even_for_recent_rule_or_procedure() {+ let recent = [+ BriefingPage {+ path: "_rules/zero.md".into(),+ title: "Zero Rule".into(),+ kind: "rule".into(),+ updated_at: "2026-06-15T00:00:00Z".into(),+ },+ BriefingPage {+ path: "procedures/zero.md".into(),+ title: "Zero Procedure".into(),+ kind: "procedure".into(),+ updated_at: "2026-06-15T00:00:00Z".into(),+ },+ ];+ let index = ExistingPageIndex::from_pages(&recent, &[]);+ let mut rule_patch = patch_proposal("append", "## Steps", "More");+ rule_patch.path = "_rules/zero.md".into();+ rule_patch.kind = "rule".into();+ let mut procedure_patch = patch_proposal("append", "## Steps", "More");+ procedure_patch.path = "procedures/zero.md".into();+ let raw = AutoImproveLlmResponse {+ summary: "ok".into(),+ proposals: vec![rule_patch, procedure_patch],+ rejected_candidates: Vec::new(),+ };++ let (accepted, rejected, _) = validate_response(raw, &cfg(), &index);+ assert!(accepted.is_empty());+ assert_eq!(rejected.len(), 2);+ assert!(+ rejected+ .iter()+ .all(|r| r.reason == "patch_target_not_in_context")+ );+ }++ #[test]+ fn duplicate_anchor_rejects() {+ let body = "# Release\n\n## Steps\nOne\n\n## Steps\nTwo\n";+ let raw = AutoImproveLlmResponse {+ summary: "ok".into(),+ proposals: vec![patch_proposal("append", "## Steps", "More")],+ rejected_candidates: Vec::new(),+ };+ let (accepted, rejected, _) =+ validate_response(raw, &cfg(), &patch_index("procedures/release.md", body));+ assert!(accepted.is_empty());+ assert_eq!(rejected[0].reason, "duplicate_anchor");+ }++ #[test]+ fn append_add_section_and_replace_section_materialize() {+ let body = "# Release\n\n## Steps\nOne\n\n## Verify\nCheck\n";+ let section_hash = parse_markdown_sections(body)+ .into_iter()+ .find(|s| s.anchor == "## Verify")+ .unwrap()+ .sha256;+ let mut candidate = patch_proposal("append", "## Steps", "Two");+ candidate.edits.push(AutoImprovePatchEdit {+ op: "add_section".into(),+ anchor: "## Steps".into(),+ content: "## Rollback\nUndo".into(),+ section_sha256: None,+ context: None,+ });+ candidate.edits.push(AutoImprovePatchEdit {+ op: "replace_section".into(),+ anchor: "## Verify".into(),+ content: "## Verify\nRun tests".into(),+ section_sha256: Some(section_hash),+ context: None,+ });+ let raw = AutoImproveLlmResponse {+ summary: "ok".into(),+ proposals: vec![candidate],+ rejected_candidates: Vec::new(),+ };+ let (accepted, rejected, _) =+ validate_response(raw, &cfg(), &patch_index("procedures/release.md", body));+ assert!(rejected.is_empty());+ let materialized = &accepted[0].body_markdown;+ assert!(materialized.contains("One"));+ assert!(materialized.contains("Two"));+ assert!(materialized.contains("## Rollback\nUndo"));+ assert!(materialized.contains("## Verify\nRun tests"));+ assert_eq!(+ accepted[0].expected_base_body_sha256.as_deref(),+ Some(sha256_hex(body.as_bytes()).as_str())+ );+ }++ #[test]+ fn replace_section_requires_matching_hash_and_delete_rejects() {+ let body = "# Release\n\n## Steps\nOne\n";+ let no_hash = patch_proposal("replace_section", "## Steps", "## Steps\nTwo");+ let mut wrong_hash = no_hash.clone();+ wrong_hash.edits[0].section_sha256 = Some("00".repeat(32));+ let delete = patch_proposal("delete_section", "## Steps", "");+ let raw = AutoImproveLlmResponse {+ summary: "ok".into(),+ proposals: vec![no_hash, wrong_hash, delete],+ rejected_candidates: Vec::new(),+ };+ let (accepted, rejected, _) =+ validate_response(raw, &cfg(), &patch_index("procedures/release.md", body));+ assert!(accepted.is_empty());+ assert!(+ rejected+ .iter()+ .any(|r| r.reason == "replace_section_missing_hash")+ );+ assert!(+ rejected+ .iter()+ .any(|r| r.reason == "replace_section_hash_mismatch")+ );+ assert!(rejected.iter().any(|r| r.reason == "unsupported_patch_op"));+ }++ #[test]+ fn replace_section_requires_same_anchor_heading() {+ let body = "# Release\n\n## Steps\nOne\n\n## Verify\nCheck\n";+ let section_hash = parse_markdown_sections(body)+ .into_iter()+ .find(|s| s.anchor == "## Steps")+ .unwrap()+ .sha256;++ let mut empty = patch_proposal("replace_section", "## Steps", "");+ empty.edits[0].section_sha256 = Some(section_hash.clone());+ let mut prose = patch_proposal("replace_section", "## Steps", "Updated prose only");+ prose.edits[0].section_sha256 = Some(section_hash.clone());+ let mut renamed = patch_proposal("replace_section", "## Steps", "## Other\nUpdated");+ renamed.edits[0].section_sha256 = Some(section_hash);+ let raw = AutoImproveLlmResponse {+ summary: "ok".into(),+ proposals: vec![empty, prose, renamed],+ rejected_candidates: Vec::new(),+ };++ let (accepted, rejected, _) =+ validate_response(raw, &cfg(), &patch_index("procedures/release.md", body));+ assert!(accepted.is_empty());+ assert!(+ rejected+ .iter()+ .any(|r| r.reason == "replace_section_missing_heading")+ );+ assert_eq!(+ rejected+ .iter()+ .filter(|r| r.reason == "replace_section_anchor_mismatch")+ .count(),+ 2+ );+ }++ #[test]+ fn patch_boundaries_preserve_following_heading() {+ let body = "# Release\n\n## Steps\nOne\n\n## Verify\nCheck\n";+ let verify_hash = parse_markdown_sections(body)+ .into_iter()+ .find(|s| s.anchor == "## Steps")+ .unwrap()+ .sha256;+ let mut replace = patch_proposal("replace_section", "## Steps", "## Steps\nOne\nTwo");+ replace.edits[0].section_sha256 = Some(verify_hash);+ let raw = AutoImproveLlmResponse {+ summary: "ok".into(),+ proposals: vec![replace],+ rejected_candidates: Vec::new(),+ };+ let (accepted, rejected, _) =+ validate_response(raw, &cfg(), &patch_index("procedures/release.md", body));+ assert!(rejected.is_empty());+ assert!(accepted[0].body_markdown.contains("Two\n\n## Verify"));++ let add = patch_proposal("add_section", "## Steps", "## Rollback\nUndo");+ let raw = AutoImproveLlmResponse {+ summary: "ok".into(),+ proposals: vec![add],+ rejected_candidates: Vec::new(),+ };+ let (accepted, rejected, _) =+ validate_response(raw, &cfg(), &patch_index("procedures/release.md", body));+ assert!(rejected.is_empty());+ assert!(+ accepted[0]+ .body_markdown+ .contains("## Rollback\nUndo\n\n## Verify")+ );+ }++ #[test]+ fn add_section_requires_non_h1_sibling_heading() {+ let body = "# Release\n\n## Steps\nOne\n";+ let missing = patch_proposal("add_section", "## Steps", "No heading");+ let h1 = patch_proposal("add_section", "## Steps", "# Bad\nNope");+ let child = patch_proposal("add_section", "## Steps", "### Child\nNope");+ let prose_before_heading = patch_proposal(+ "add_section",+ "## Steps",+ "Introductory prose.\n\n## Rollback\nUndo",+ );+ let raw = AutoImproveLlmResponse {+ summary: "ok".into(),+ proposals: vec![missing, h1, child, prose_before_heading],+ rejected_candidates: Vec::new(),+ };+ let (accepted, rejected, _) =+ validate_response(raw, &cfg(), &patch_index("procedures/release.md", body));+ assert!(accepted.is_empty());+ assert!(+ rejected+ .iter()+ .any(|r| r.reason == "add_section_missing_heading")+ );+ assert_eq!(+ rejected+ .iter()+ .filter(|r| r.reason == "add_section_missing_heading")+ .count(),+ 2+ );+ assert!(+ rejected+ .iter()+ .any(|r| r.reason == "add_section_h1_unsupported")+ );+ assert!(+ rejected+ .iter()+ .any(|r| r.reason == "add_section_heading_level_mismatch")+ );+ }++ #[test]+ fn heading_parser_ignores_fenced_code_headings() {+ let body = "# Release\n\n```\n## Not Anchor\n```\n\n## Steps\nOne\n";+ let sections = parse_markdown_sections(body);+ assert!(sections.iter().any(|s| s.anchor == "## Steps"));+ assert!(!sections.iter().any(|s| s.anchor == "## Not Anchor"));+ }++ #[test]+ fn patch_rejects_duplicate_headings_and_extra_h1_introduced_by_edits() {+ let body = "# Release\n\n## Steps\nOne\n";+ let duplicate = patch_proposal("append", "## Steps", "## Steps\nAgain");+ let extra_h1 = patch_proposal("append", "## Steps", "# Extra\nNope");+ let raw = AutoImproveLlmResponse {+ summary: "ok".into(),+ proposals: vec![duplicate, extra_h1],+ rejected_candidates: Vec::new(),+ };+ let (accepted, rejected, _) =+ validate_response(raw, &cfg(), &patch_index("procedures/release.md", body));+ assert!(accepted.is_empty());+ assert!(rejected.iter().any(|r| r.reason == "duplicate_anchor"));+ assert!(rejected.iter().any(|r| r.reason == "patch_extra_h1"));+ }}diff --git a/crates/ai-memory-consolidate/src/lib.rs b/crates/ai-memory-consolidate/src/lib.rsindex f0929197..f72cab55 100644--- a/crates/ai-memory-consolidate/src/lib.rs+++ b/crates/ai-memory-consolidate/src/lib.rs@@ -18,12 +18,19 @@ pub mod sweep;pub mod types;pub use auto_improve::{- AutoImproveError, AutoImproveEvidence, AutoImproveLlmResponse, AutoImproveProposal,- AutoImproveRejectedCandidate, AutoImproveReport, AutoImproveReviewConfig,- DEFAULT_AUTO_IMPROVE_MAX_INPUT_TOKENS, DEFAULT_AUTO_IMPROVE_MAX_PROPOSALS,- DEFAULT_AUTO_IMPROVE_MIN_CONFIDENCE, DEFAULT_AUTO_IMPROVE_MIN_OBSERVATIONS,- DEFAULT_AUTO_IMPROVE_MIN_SESSION_DURATION_SECS, DEFAULT_AUTO_IMPROVE_PENDING_PATH,- DEFAULT_AUTO_IMPROVE_PROPOSAL_ACTOR, run_auto_improve_review,+ AutoImproveError, AutoImproveEvalConfig, AutoImproveEvidence, AutoImproveLlmResponse,+ AutoImproveProposal, AutoImproveRejectedCandidate, AutoImproveReport, AutoImproveReviewConfig,+ DEFAULT_AUTO_IMPROVE_MAX_CHANGED_CHARS_PER_PROPOSAL,+ DEFAULT_AUTO_IMPROVE_MAX_EDIT_CONTENT_CHARS, DEFAULT_AUTO_IMPROVE_MAX_EDITS_PER_PROPOSAL,+ DEFAULT_AUTO_IMPROVE_MAX_FINAL_BODY_CHARS, DEFAULT_AUTO_IMPROVE_MAX_INPUT_TOKENS,+ DEFAULT_AUTO_IMPROVE_MAX_PATCH_EDITS_PER_RUN, DEFAULT_AUTO_IMPROVE_MAX_PATCHABLE_BODY_CHARS,+ DEFAULT_AUTO_IMPROVE_MAX_PATCHABLE_PAGES, DEFAULT_AUTO_IMPROVE_MAX_PROCEDURE_PAGE_TOKENS,+ DEFAULT_AUTO_IMPROVE_MAX_PROPOSALS, DEFAULT_AUTO_IMPROVE_MAX_REJECTION_CONTEXT,+ DEFAULT_AUTO_IMPROVE_MAX_RULE_PAGE_TOKENS, DEFAULT_AUTO_IMPROVE_MIN_CONFIDENCE,+ DEFAULT_AUTO_IMPROVE_MIN_OBSERVATIONS, DEFAULT_AUTO_IMPROVE_MIN_SESSION_DURATION_SECS,+ DEFAULT_AUTO_IMPROVE_PENDING_PATH, DEFAULT_AUTO_IMPROVE_PROPOSAL_ACTOR,+ DEFAULT_AUTO_IMPROVE_REJECTION_CONTEXT_DAYS, default_auto_improve_eval_targets,+ run_auto_improve_review,};pub use bootstrap::{Bootstrap, BootstrapConfig, BootstrapError, BootstrapOutcome, BootstrapSource,diff --git a/crates/ai-memory-mcp/src/admin.rs b/crates/ai-memory-mcp/src/admin.rsindex 8ff54778..3acae802 100644--- a/crates/ai-memory-mcp/src/admin.rs+++ b/crates/ai-memory-mcp/src/admin.rs@@ -81,6 +81,10 @@ pub struct AdminState {/// approval; otherwise it approves them immediately through the normal wiki/// write path.pub auto_improve_require_approval: bool,+ /// Server-configured defaults used by direct admin auto-improvement.+ /// Request fields remain explicit overrides; omitted eval settings inherit+ /// this operator policy instead of disabling eval silently.+ pub auto_improve_review_config: AutoImproveReviewConfig,/// Optional embedder. When `None`, `/admin/embed` returns 503.pub embedder: Option<Arc<dyn Embedder>>,/// Passive process-scoped health recorder for configured providers.@@ -191,12 +195,50 @@ struct AutoImproveRequest {/// Whether future raw fallback details may be considered.#[serde(default)]include_raw_fallback: bool,+ /// Maximum existing _rules/ and procedures/ pages included for patch proposals.+ #[serde(default = "default_auto_improve_max_patchable_pages")]+ max_patchable_pages: usize,+ /// Maximum body chars rendered per patchable target page.+ #[serde(default = "default_auto_improve_max_patchable_body_chars")]+ max_patchable_body_chars: usize,+ /// Maximum patch edits per proposal.+ #[serde(default = "default_auto_improve_max_edits_per_proposal")]+ max_edits_per_proposal: usize,+ /// Maximum content chars in one patch edit.+ #[serde(default = "default_auto_improve_max_edit_content_chars")]+ max_edit_content_chars: usize,+ /// Maximum aggregate changed chars in one patch proposal.+ #[serde(default = "default_auto_improve_max_changed_chars_per_proposal")]+ max_changed_chars_per_proposal: usize,+ /// Maximum patch edits accepted across one review run.+ #[serde(default = "default_auto_improve_max_patch_edits_per_run")]+ max_patch_edits_per_run: usize,+ /// Maximum recent rejection-buffer entries rendered into prompt context.+ #[serde(default = "default_auto_improve_max_rejection_context")]+ max_rejection_context: usize,+ /// Maximum age in days for rejection-buffer prompt context.+ #[serde(default = "default_auto_improve_rejection_context_days")]+ rejection_context_days: u32,+ /// Maximum materialized final body size.+ #[serde(default = "default_auto_improve_max_final_body_chars")]+ max_final_body_chars: usize,+ /// Maximum approximate tokens allowed in one _rules/ page.+ #[serde(default = "default_auto_improve_max_rule_page_tokens")]+ max_rule_page_tokens: usize,+ /// Maximum approximate tokens allowed in one procedures/ page.+ #[serde(default = "default_auto_improve_max_procedure_page_tokens")]+ max_procedure_page_tokens: usize,/// Synthetic actor used for staged proposal provenance.#[serde(default = "default_auto_improve_proposal_actor")]proposal_actor: String,/// Pending proposal sidecar folder.#[serde(default = "default_auto_improve_pending_path")]pending_path: String,+ /// Optional executable proposal eval gate. When omitted, direct admin+ /// requests inherit the server's configured eval policy; CLI requests send+ /// their local config explicitly.+ #[serde(default)]+ eval: Option<ai_memory_consolidate::AutoImproveEvalConfig>,/// Removed compatibility field. Requests that still send it fail closed so/// old preview callers cannot accidentally write pages.#[serde(default)]@@ -303,6 +345,50 @@ fn default_auto_improve_max_proposals() -> usize {ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MAX_PROPOSALS}+fn default_auto_improve_max_patchable_pages() -> usize {+ ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MAX_PATCHABLE_PAGES+}++fn default_auto_improve_max_patchable_body_chars() -> usize {+ ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MAX_PATCHABLE_BODY_CHARS+}++fn default_auto_improve_max_edits_per_proposal() -> usize {+ ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MAX_EDITS_PER_PROPOSAL+}++fn default_auto_improve_max_edit_content_chars() -> usize {+ ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MAX_EDIT_CONTENT_CHARS+}++fn default_auto_improve_max_changed_chars_per_proposal() -> usize {+ ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MAX_CHANGED_CHARS_PER_PROPOSAL+}++fn default_auto_improve_max_patch_edits_per_run() -> usize {+ ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MAX_PATCH_EDITS_PER_RUN+}++fn default_auto_improve_max_rejection_context() -> usize {+ ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MAX_REJECTION_CONTEXT+}++fn default_auto_improve_rejection_context_days() -> u32 {+ ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_REJECTION_CONTEXT_DAYS+}++fn default_auto_improve_max_final_body_chars() -> usize {+ ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MAX_FINAL_BODY_CHARS+}++fn default_auto_improve_max_rule_page_tokens() -> usize {+ ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MAX_RULE_PAGE_TOKENS+}++fn default_auto_improve_max_procedure_page_tokens() -> usize {+ ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MAX_PROCEDURE_PAGE_TOKENS+}+fn default_auto_improve_proposal_actor() -> String {ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_PROPOSAL_ACTOR.into()}@@ -311,6 +397,18 @@ fn default_auto_improve_pending_path() -> String {ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_PENDING_PATH.into()}+fn hex_to_sha256(hex: &str) -> Result<[u8; 32], String> {+ if hex.len() != 64 {+ return Err("expected 64 hex chars".into());+ }+ let mut out = [0_u8; 32];+ for (idx, chunk) in hex.as_bytes().chunks_exact(2).enumerate() {+ let s = std::str::from_utf8(chunk).map_err(|e| e.to_string())?;+ out[idx] = u8::from_str_radix(s, 16).map_err(|e| e.to_string())?;+ }+ Ok(out)+}+/// Build the admin axum [`Router`]. Mounts:/// - `POST /admin/backup`/// - `POST /admin/bootstrap`@@ -1114,14 +1212,30 @@ async fn handle_auto_improve(include_raw_fallback: req.include_raw_fallback,proposal_actor: req.proposal_actor.clone(),pending_path: req.pending_path.clone(),+ max_patchable_pages: req.max_patchable_pages,+ max_patchable_body_chars: req.max_patchable_body_chars,+ max_edits_per_proposal: req.max_edits_per_proposal,+ max_edit_content_chars: req.max_edit_content_chars,+ max_changed_chars_per_proposal: req.max_changed_chars_per_proposal,+ max_patch_edits_per_run: req.max_patch_edits_per_run,+ max_rejection_context: req.max_rejection_context,+ rejection_context_days: req.rejection_context_days,+ max_final_body_chars: req.max_final_body_chars,+ max_rule_page_tokens: req.max_rule_page_tokens,+ max_procedure_page_tokens: req.max_procedure_page_tokens,+ eval: req+ .eval+ .clone()+ .unwrap_or_else(|| state.auto_improve_review_config.eval.clone()),};- let report = run_auto_improve_review(&state.reader, &*llm, ws, proj, req.session_id, cfg)- .await- .map_err(auto_improve_error_response)?;+ let report =+ run_auto_improve_review(&state.reader, &*llm, ws, proj, req.session_id, cfg.clone())+ .await+ .map_err(auto_improve_error_response)?;let proposals = auto_improve_new_proposals(&state, ws, proj, &report).await?;let staged =- stage_auto_improve_report(&state, ws, proj, req.session_id, &req, &report, proposals)+ stage_auto_improve_report(&state, ws, proj, req.session_id, &cfg, &report, proposals).await?;let actor = actor_ext.map(|axum::Extension(actor)| actor)@@ -1249,17 +1363,25 @@ async fn auto_improve_new_proposals(Json(serde_json::json!({ "error": format!("invalid proposal path: {e}") })),)})?;- let operation = if state+ let target_exists = state.reader.page_body_by_ids(ws, proj, path.as_str()).await.map_err(|e| internal_err(e.to_string()))?- .is_some()+ .is_some();+ let operation = if p.edit_mode == "patch"+ || (target_exists && path.as_str() == "_slots/current-focus.md"){AutoImproveProposalOperation::Update} else {AutoImproveProposalOperation::Create};+ let expected_base_body_sha256 = p+ .expected_base_body_sha256+ .as_deref()+ .map(hex_to_sha256)+ .transpose()+ .map_err(|e| internal_err(format!("invalid expected_base_body_sha256: {e}")))?;proposals.push(NewAutoImproveProposal {operation,target_path: path,@@ -1271,6 +1393,9 @@ async fn auto_improve_new_proposals(.map_err(|e| internal_err(e.to_string()))?,body_markdown: p.body_markdown.clone(),artifact_sha256: None,+ edit_mode: Some(p.edit_mode.clone()),+ patch_json: serde_json::to_value(&p.edits).ok(),+ expected_base_body_sha256,});}Ok(proposals)@@ -1287,7 +1412,7 @@ async fn stage_auto_improve_report(ws: WorkspaceId,proj: ProjectId,session_id: SessionId,- req: &AutoImproveRequest,+ cfg: &AutoImproveReviewConfig,report: &ai_memory_consolidate::AutoImproveReport,proposals: Vec<NewAutoImproveProposal>,) -> Result<StagedAutoImproveData, (StatusCode, Json<serde_json::Value>)> {@@ -1305,15 +1430,27 @@ async fn stage_auto_improve_report(rejected_candidates_json: serde_json::to_value(&report.rejected_candidates).unwrap_or_else(|_| serde_json::json!([])),config_json: serde_json::json!({- "min_observations": req.min_observations,- "min_session_duration_secs": req.min_session_duration_secs,- "min_confidence": req.min_confidence,- "max_input_tokens": req.max_input_tokens,- "max_proposals_per_run": req.max_proposals_per_run,- "include_raw_fallback": req.include_raw_fallback,+ "min_observations": cfg.min_observations,+ "min_session_duration_secs": cfg.min_session_duration_secs,+ "min_confidence": cfg.min_confidence,+ "max_input_tokens": cfg.max_input_tokens,+ "max_proposals_per_run": cfg.max_proposals_per_run,+ "include_raw_fallback": cfg.include_raw_fallback,+ "max_patchable_pages": cfg.max_patchable_pages,+ "max_patchable_body_chars": cfg.max_patchable_body_chars,+ "max_edits_per_proposal": cfg.max_edits_per_proposal,+ "max_edit_content_chars": cfg.max_edit_content_chars,+ "max_changed_chars_per_proposal": cfg.max_changed_chars_per_proposal,+ "max_patch_edits_per_run": cfg.max_patch_edits_per_run,+ "max_rejection_context": cfg.max_rejection_context,+ "rejection_context_days": cfg.rejection_context_days,+ "max_final_body_chars": cfg.max_final_body_chars,+ "max_rule_page_tokens": cfg.max_rule_page_tokens,+ "max_procedure_page_tokens": cfg.max_procedure_page_tokens,+ "eval": cfg.eval,}),proposal_actor: ai_memory_core::ActorContext {- agent: Some(req.proposal_actor.clone()),+ agent: Some(cfg.proposal_actor.clone()),..ai_memory_core::ActorContext::default()},proposals,@@ -1344,6 +1481,7 @@ fn auto_improve_error_response(AutoImproveError::SessionNotFound(_) => StatusCode::NOT_FOUND,AutoImproveError::SessionOutOfScope { .. } => StatusCode::UNPROCESSABLE_ENTITY,AutoImproveError::Llm(_) => StatusCode::BAD_GATEWAY,+ AutoImproveError::Eval(_) => StatusCode::BAD_GATEWAY,AutoImproveError::Memory(_) => StatusCode::BAD_REQUEST,AutoImproveError::Store(_) => StatusCode::INTERNAL_SERVER_ERROR,};@@ -1451,6 +1589,9 @@ async fn handle_curator(}),body_markdown,artifact_sha256: None,+ edit_mode: None,+ patch_json: None,+ expected_base_body_sha256: None,}],}).await@@ -4266,6 +4407,7 @@ mod tests {wiki,llm: None,auto_improve_require_approval: false,+ auto_improve_review_config: Default::default(),embedder: None,provider_health: ProviderHealth::default(),decay_params: DecayParams::default(),@@ -4308,6 +4450,7 @@ mod tests {wiki,llm: None,auto_improve_require_approval: false,+ auto_improve_review_config: Default::default(),embedder: None,provider_health: ProviderHealth::default(),decay_params: DecayParams::default(),@@ -4339,6 +4482,7 @@ mod tests {wiki,llm,auto_improve_require_approval: false,+ auto_improve_review_config: Default::default(),embedder: None,provider_health: ProviderHealth::default(),decay_params: DecayParams::default(),@@ -4396,6 +4540,9 @@ mod tests {evidence_json: serde_json::json!([{"source":"test"}]),body_markdown: body.into(),artifact_sha256: None,+ edit_mode: None,+ patch_json: None,+ expected_base_body_sha256: None,}],}).await@@ -4719,6 +4866,101 @@ mod tests {);}+ #[tokio::test]+ async fn auto_improve_admin_omitted_eval_inherits_server_defaults() {+ let tmp = TempDir::new().unwrap();+ let store = Store::open(tmp.path()).unwrap();+ let wiki = Wiki::new(tmp.path(), store.writer.clone())+ .unwrap()+ .with_store_reader(store.reader.clone());+ let ws = store+ .writer+ .get_or_create_workspace("default")+ .await+ .unwrap();+ let proj = store+ .writer+ .get_or_create_project(ws, "scratch", None)+ .await+ .unwrap();+ let session_id = SessionId::new();+ store+ .writer+ .begin_session(NewSession {+ id: session_id,+ workspace_id: ws,+ project_id: proj,+ agent_kind: AgentKind::Other,+ cwd: None,+ })+ .await+ .unwrap();+ store+ .writer+ .insert_observation(NewObservation {+ session_id,+ workspace_id: ws,+ project_id: proj,+ kind: ObservationKind::UserPrompt,+ extension: None,+ source_event: None,+ title: "prompt".into(),+ body: "focus changed and durable lesson".into(),+ importance: 5,+ })+ .await+ .unwrap();+ let mut state =+ admin_state_for_store_with_llm(&tmp, &store, wiki, Some(Arc::new(FakeAutoImproveLlm)));+ state.auto_improve_review_config.eval = ai_memory_consolidate::AutoImproveEvalConfig {+ enabled: true,+ command: String::new(),+ timeout_secs: 1,+ targets: vec!["notes".into()],+ min_delta: 0.0,+ };+ let router = admin_router(state);++ let resp = router+ .oneshot(+ Request::builder()+ .method("POST")+ .uri("/admin/auto-improve")+ .header("content-type", "application/json")+ .body(Body::from(+ serde_json::to_vec(&serde_json::json!({+ "workspace": "default",+ "project": "scratch",+ "session_id": session_id.to_string(),+ "min_observations": 1,+ "min_session_duration_secs": 0,+ "min_confidence": 0.75,+ "max_proposals_per_run": 5+ }))+ .unwrap(),+ ))+ .unwrap(),+ )+ .await+ .unwrap();++ assert_eq!(resp.status(), StatusCode::OK);+ let body = to_bytes(resp.into_body(), usize::MAX).await.unwrap();+ let json: serde_json::Value = serde_json::from_slice(&body).unwrap();+ assert_eq!(json["rejected_candidates_count"], 1);+ let proposals = json["proposals"].as_array().unwrap();+ assert_eq!(proposals.len(), 1);+ assert_eq!(+ store+ .reader+ .list_auto_improve_proposals(ws, proj, None, 10)+ .await+ .unwrap()+ .len(),+ 1+ );+ }+#[tokio::test]async fn auto_improve_require_approval_keeps_proposals_pending() {let tmp = TempDir::new().unwrap();@@ -5289,6 +5531,7 @@ mod tests {wiki,llm: None,auto_improve_require_approval: false,+ auto_improve_review_config: Default::default(),embedder: None,provider_health: ProviderHealth::default(),decay_params: DecayParams::default(),@@ -5396,6 +5639,7 @@ mod tests {wiki,llm: None,auto_improve_require_approval: false,+ auto_improve_review_config: Default::default(),embedder: None,provider_health: ProviderHealth::default(),decay_params: DecayParams::default(),@@ -5496,6 +5740,7 @@ mod tests {wiki,llm: None,auto_improve_require_approval: false,+ auto_improve_review_config: Default::default(),embedder: None,provider_health: ProviderHealth::default(),decay_params: DecayParams::default(),@@ -5602,6 +5847,7 @@ mod tests {wiki,llm: None,auto_improve_require_approval: false,+ auto_improve_review_config: Default::default(),embedder: None,provider_health: ProviderHealth::default(),decay_params: DecayParams::default(),@@ -5687,6 +5933,7 @@ mod tests {wiki,llm: None,auto_improve_require_approval: false,+ auto_improve_review_config: Default::default(),embedder: None,provider_health: ProviderHealth::default(),decay_params: DecayParams::default(),@@ -6191,6 +6438,7 @@ mod tests {wiki,llm: None,auto_improve_require_approval: false,+ auto_improve_review_config: Default::default(),embedder: None,provider_health: ProviderHealth::default(),decay_params: DecayParams::default(),diff --git a/crates/ai-memory-mcp/src/server.rs b/crates/ai-memory-mcp/src/server.rsindex cd1592db..962afa22 100644--- a/crates/ai-memory-mcp/src/server.rs+++ b/crates/ai-memory-mcp/src/server.rs@@ -32,6 +32,36 @@ const HANDOFF_TEXT_LIST_MAX_CHARS: usize = 6_000;const HANDOFF_FILE_LIST_MAX_CHARS: usize = 4_096;const HANDOFF_LIST_MAX_ITEMS: usize = 20;+fn default_auto_improve_review_config() -> AutoImproveReviewConfig {+ AutoImproveReviewConfig {+ min_observations: ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MIN_OBSERVATIONS,+ min_session_duration_secs:+ ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MIN_SESSION_DURATION_SECS,+ min_confidence: ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MIN_CONFIDENCE,+ max_input_tokens: ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MAX_INPUT_TOKENS,+ max_proposals_per_run: ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MAX_PROPOSALS,+ include_raw_fallback: false,+ proposal_actor: ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_PROPOSAL_ACTOR.into(),+ pending_path: ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_PENDING_PATH.into(),+ max_patchable_pages: ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MAX_PATCHABLE_PAGES,+ max_patchable_body_chars:+ ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MAX_PATCHABLE_BODY_CHARS,+ max_edits_per_proposal: ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MAX_EDITS_PER_PROPOSAL,+ max_edit_content_chars: ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MAX_EDIT_CONTENT_CHARS,+ max_changed_chars_per_proposal:+ ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MAX_CHANGED_CHARS_PER_PROPOSAL,+ max_patch_edits_per_run:+ ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MAX_PATCH_EDITS_PER_RUN,+ max_rejection_context: ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MAX_REJECTION_CONTEXT,+ rejection_context_days: ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_REJECTION_CONTEXT_DAYS,+ max_final_body_chars: ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MAX_FINAL_BODY_CHARS,+ max_rule_page_tokens: ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MAX_RULE_PAGE_TOKENS,+ max_procedure_page_tokens:+ ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MAX_PROCEDURE_PAGE_TOKENS,+ eval: ai_memory_consolidate::AutoImproveEvalConfig::default(),+ }+}+fn cap_handoff_list<I>(items: I,item_max_chars: usize,@@ -286,6 +316,10 @@ pub struct AiMemoryServer {/// otherwise it immediately approves validated proposals through the normal/// wiki write path.auto_improve_require_approval: bool,+ /// Server-configured defaults used by manual MCP auto-improvement. This+ /// keeps manual runs at least as strict as the operator's configured+ /// Phase 1/2 budgets instead of falling back to compiled defaults.+ auto_improve_review_config: AutoImproveReviewConfig,// Read by the `#[tool_handler]` macro expansion; rustc's dead-code// analysis can't see that, so the lint must be allowed explicitly.#[allow(dead_code)]@@ -695,6 +729,7 @@ impl AiMemoryServer {embedder: None,sanitizer: ai_memory_core::Sanitizer::builtin(),auto_improve_require_approval: false,+ auto_improve_review_config: default_auto_improve_review_config(),tool_router: Self::tool_router(),}}@@ -706,6 +741,13 @@ impl AiMemoryServer {self}+ /// Configure manual MCP auto-improve review budgets from server config.+ #[must_use]+ pub fn with_auto_improve_review_config(mut self, config: AutoImproveReviewConfig) -> Self {+ self.auto_improve_review_config = config;+ self+ }+/// Replace the default built-in-only sanitizer with one carrying/// the operator's `[sanitize]` extras + allowlist.#[must_use]@@ -1304,25 +1346,32 @@ impl AiMemoryServer {)})?,};+ let defaults = &self.auto_improve_review_config;let cfg = AutoImproveReviewConfig {- min_observations: args- .min_observations- .unwrap_or(ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MIN_OBSERVATIONS),+ min_observations: args.min_observations.unwrap_or(defaults.min_observations),min_session_duration_secs: args.min_session_duration_secs- .unwrap_or(ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MIN_SESSION_DURATION_SECS),- min_confidence: args- .min_confidence- .unwrap_or(ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MIN_CONFIDENCE),- max_input_tokens: args- .max_input_tokens- .unwrap_or(ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MAX_INPUT_TOKENS),- max_proposals_per_run: args- .max_proposals- .unwrap_or(ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_MAX_PROPOSALS),- include_raw_fallback: args.include_raw_fallback.unwrap_or(false),- proposal_actor: ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_PROPOSAL_ACTOR.into(),- pending_path: ai_memory_consolidate::DEFAULT_AUTO_IMPROVE_PENDING_PATH.into(),+ .unwrap_or(defaults.min_session_duration_secs),+ min_confidence: args.min_confidence.unwrap_or(defaults.min_confidence),+ max_input_tokens: args.max_input_tokens.unwrap_or(defaults.max_input_tokens),+ max_proposals_per_run: args.max_proposals.unwrap_or(defaults.max_proposals_per_run),+ include_raw_fallback: args+ .include_raw_fallback+ .unwrap_or(defaults.include_raw_fallback),+ proposal_actor: defaults.proposal_actor.clone(),+ pending_path: defaults.pending_path.clone(),+ max_patchable_pages: defaults.max_patchable_pages,+ max_patchable_body_chars: defaults.max_patchable_body_chars,+ max_edits_per_proposal: defaults.max_edits_per_proposal,+ max_edit_content_chars: defaults.max_edit_content_chars,+ max_changed_chars_per_proposal: defaults.max_changed_chars_per_proposal,+ max_patch_edits_per_run: defaults.max_patch_edits_per_run,+ max_rejection_context: defaults.max_rejection_context,+ rejection_context_days: defaults.rejection_context_days,+ max_final_body_chars: defaults.max_final_body_chars,+ max_rule_page_tokens: defaults.max_rule_page_tokens,+ max_procedure_page_tokens: defaults.max_procedure_page_tokens,+ eval: defaults.eval.clone(),};let report =@@ -1334,17 +1383,30 @@ impl AiMemoryServer {let path = PagePath::new(p.path.clone()).map_err(|e| {McpError::invalid_params(format!("invalid proposal path: {e}"), None)})?;- let operation = if self+ let target_exists = self.reader.page_body_by_ids(ws, proj, path.as_str()).await.map_err(|e| McpError::internal_error(e.to_string(), None))?- .is_some()+ .is_some();+ let operation = if p.edit_mode == "patch"+ || (target_exists && path.as_str() == "_slots/current-focus.md"){AutoImproveProposalOperation::Update} else {AutoImproveProposalOperation::Create};+ let expected_base_body_sha256 = p+ .expected_base_body_sha256+ .as_deref()+ .map(hex_to_sha256)+ .transpose()+ .map_err(|e| {+ McpError::internal_error(+ format!("invalid expected_base_body_sha256: {e}"),+ None,+ )+ })?;proposals.push(NewAutoImproveProposal {operation,target_path: path,@@ -1356,6 +1418,9 @@ impl AiMemoryServer {.map_err(|e| McpError::internal_error(e.to_string(), None))?,body_markdown: p.body_markdown.clone(),artifact_sha256: None,+ edit_mode: Some(p.edit_mode.clone()),+ patch_json: serde_json::to_value(&p.edits).ok(),+ expected_base_body_sha256,});}let staged = self@@ -1378,6 +1443,18 @@ impl AiMemoryServer {"max_input_tokens": cfg.max_input_tokens,"max_proposals_per_run": cfg.max_proposals_per_run,"include_raw_fallback": cfg.include_raw_fallback,+ "max_patchable_pages": cfg.max_patchable_pages,+ "max_patchable_body_chars": cfg.max_patchable_body_chars,+ "max_edits_per_proposal": cfg.max_edits_per_proposal,+ "max_edit_content_chars": cfg.max_edit_content_chars,+ "max_changed_chars_per_proposal": cfg.max_changed_chars_per_proposal,+ "max_patch_edits_per_run": cfg.max_patch_edits_per_run,+ "max_rejection_context": cfg.max_rejection_context,+ "rejection_context_days": cfg.rejection_context_days,+ "max_final_body_chars": cfg.max_final_body_chars,+ "max_rule_page_tokens": cfg.max_rule_page_tokens,+ "max_procedure_page_tokens": cfg.max_procedure_page_tokens,+ "eval": cfg.eval,}),proposal_actor: ai_memory_core::ActorContext {agent: Some(cfg.proposal_actor.clone()),@@ -2098,6 +2175,18 @@ impl AiMemoryServer {}}+fn hex_to_sha256(hex: &str) -> Result<[u8; 32], String> {+ if hex.len() != 64 {+ return Err("expected 64 hex chars".into());+ }+ let mut out = [0_u8; 32];+ for (idx, chunk) in hex.as_bytes().chunks_exact(2).enumerate() {+ let s = std::str::from_utf8(chunk).map_err(|e| e.to_string())?;+ out[idx] = u8::from_str_radix(s, 16).map_err(|e| e.to_string())?;+ }+ Ok(out)+}+#[tool_handler]impl ServerHandler for AiMemoryServer {fn get_info(&self) -> ServerInfo {diff --git a/crates/ai-memory-mcp/tests/admin_backup.rs b/crates/ai-memory-mcp/tests/admin_backup.rsindex 09606441..bc9f4341 100644--- a/crates/ai-memory-mcp/tests/admin_backup.rs+++ b/crates/ai-memory-mcp/tests/admin_backup.rs@@ -29,6 +29,7 @@ async fn make_state(tmp: &TempDir) -> (AdminState, Store) {wiki,llm: None,auto_improve_require_approval: false,+ auto_improve_review_config: Default::default(),embedder: None,provider_health: ai_memory_llm::ProviderHealth::default(),decay_params: DecayParams::default(),diff --git a/crates/ai-memory-mcp/tests/admin_bootstrap.rs b/crates/ai-memory-mcp/tests/admin_bootstrap.rsindex fa263571..21ae7e34 100644--- a/crates/ai-memory-mcp/tests/admin_bootstrap.rs+++ b/crates/ai-memory-mcp/tests/admin_bootstrap.rs@@ -26,6 +26,7 @@ async fn make_admin_state(tmp: &TempDir) -> AdminState {wiki,llm: None, // no LLM — bootstrap report path onlyauto_improve_require_approval: false,+ auto_improve_review_config: Default::default(),embedder: None,provider_health: ai_memory_llm::ProviderHealth::default(),decay_params: DecayParams::default(),diff --git a/crates/ai-memory-mcp/tests/admin_move.rs b/crates/ai-memory-mcp/tests/admin_move.rsindex 9cfd0028..af630674 100644--- a/crates/ai-memory-mcp/tests/admin_move.rs+++ b/crates/ai-memory-mcp/tests/admin_move.rs@@ -42,6 +42,7 @@ async fn make_state(tmp: &TempDir) -> (AdminState, Store) {wiki,llm: None,auto_improve_require_approval: false,+ auto_improve_review_config: Default::default(),embedder: None,provider_health: ai_memory_llm::ProviderHealth::default(),decay_params: DecayParams::default(),@@ -396,6 +397,7 @@ async fn move_project_carries_source_embedding() {wiki,llm: None,auto_improve_require_approval: false,+ auto_improve_review_config: Default::default(),embedder: Some(embedder),provider_health: ai_memory_llm::ProviderHealth::default(),decay_params: DecayParams::default(),@@ -679,6 +681,7 @@ async fn true_move_notifies_admission_with_destination_names() {wiki,llm: None,auto_improve_require_approval: false,+ auto_improve_review_config: Default::default(),embedder: None,provider_health: ai_memory_llm::ProviderHealth::default(),decay_params: DecayParams::default(),@@ -732,6 +735,7 @@ async fn make_state_with_embedder(tmp: &TempDir) -> (AdminState, Store) {wiki,llm: None,auto_improve_require_approval: false,+ auto_improve_review_config: Default::default(),embedder: Some(embedder),provider_health: ai_memory_llm::ProviderHealth::default(),decay_params: DecayParams::default(),@@ -884,6 +888,7 @@ fn build_state(store: &Store, tmp: &TempDir) -> AdminState {wiki: Wiki::new(tmp.path(), store.writer.clone()).unwrap(),llm: None,auto_improve_require_approval: false,+ auto_improve_review_config: Default::default(),embedder: None,provider_health: ai_memory_llm::ProviderHealth::default(),decay_params: DecayParams::default(),@@ -1379,6 +1384,7 @@ async fn true_move_aborts_when_admission_rejects() {wiki,llm: None,auto_improve_require_approval: false,+ auto_improve_review_config: Default::default(),embedder: None,provider_health: ai_memory_llm::ProviderHealth::default(),decay_params: DecayParams::default(),@@ -1473,6 +1479,7 @@ async fn copy_purge_purge_admission_runs_before_db_destruction() {wiki,llm: None,auto_improve_require_approval: false,+ auto_improve_review_config: Default::default(),embedder: None,provider_health: ai_memory_llm::ProviderHealth::default(),decay_params: DecayParams::default(),diff --git a/crates/ai-memory-mcp/tests/admin_phase3.rs b/crates/ai-memory-mcp/tests/admin_phase3.rsindex 90742cd2..53677aa0 100644--- a/crates/ai-memory-mcp/tests/admin_phase3.rs+++ b/crates/ai-memory-mcp/tests/admin_phase3.rs@@ -37,6 +37,7 @@ async fn make_state(tmp: &TempDir) -> (AdminState, Store) {wiki,llm: None,auto_improve_require_approval: false,+ auto_improve_review_config: Default::default(),embedder: None,provider_health: ai_memory_llm::ProviderHealth::default(),decay_params: DecayParams::default(),diff --git a/crates/ai-memory-mcp/tests/admin_purge.rs b/crates/ai-memory-mcp/tests/admin_purge.rsindex 6d771ff3..cf8f714f 100644--- a/crates/ai-memory-mcp/tests/admin_purge.rs+++ b/crates/ai-memory-mcp/tests/admin_purge.rs@@ -35,6 +35,7 @@ async fn make_state(tmp: &TempDir) -> (AdminState, Store) {wiki,llm: None,auto_improve_require_approval: false,+ auto_improve_review_config: Default::default(),embedder: None,provider_health: ai_memory_llm::ProviderHealth::default(),decay_params: DecayParams::default(),@@ -341,6 +342,7 @@ async fn purge_project_rejecting_admission_leaves_source_intact() {wiki,llm: None,auto_improve_require_approval: false,+ auto_improve_review_config: Default::default(),embedder: None,provider_health: ai_memory_llm::ProviderHealth::default(),decay_params: DecayParams::default(),@@ -441,6 +443,7 @@ async fn purge_project_idempotent_second_call_is_404() {wiki: state_a.wiki.clone(),llm: None,auto_improve_require_approval: false,+ auto_improve_review_config: Default::default(),embedder: None,provider_health: ai_memory_llm::ProviderHealth::default(),decay_params: DecayParams::default(),diff --git a/crates/ai-memory-mcp/tests/admin_read_page.rs b/crates/ai-memory-mcp/tests/admin_read_page.rsindex e8b0f633..23fb4604 100644--- a/crates/ai-memory-mcp/tests/admin_read_page.rs+++ b/crates/ai-memory-mcp/tests/admin_read_page.rs@@ -22,6 +22,7 @@ async fn make_state(tmp: &TempDir) -> (AdminState, Store) {wiki,llm: None,auto_improve_require_approval: false,+ auto_improve_review_config: Default::default(),embedder: None,provider_health: ai_memory_llm::ProviderHealth::default(),decay_params: DecayParams::default(),diff --git a/crates/ai-memory-mcp/tests/admin_rename.rs b/crates/ai-memory-mcp/tests/admin_rename.rsindex 3c4ca076..9a67a8ea 100644--- a/crates/ai-memory-mcp/tests/admin_rename.rs+++ b/crates/ai-memory-mcp/tests/admin_rename.rs@@ -28,6 +28,7 @@ async fn make_state(tmp: &TempDir) -> (AdminState, Store) {wiki,llm: None,auto_improve_require_approval: false,+ auto_improve_review_config: Default::default(),embedder: None,provider_health: ai_memory_llm::ProviderHealth::default(),decay_params: DecayParams::default(),@@ -315,6 +316,7 @@ async fn rename_project_pages_still_searchable() {wiki: state.wiki.clone(),llm: None,auto_improve_require_approval: false,+ auto_improve_review_config: Default::default(),embedder: None,provider_health: ai_memory_llm::ProviderHealth::default(),decay_params: DecayParams::default(),@@ -386,6 +388,7 @@ async fn rename_project_after_purge_returns_404_not_silent_200() {wiki: state.wiki.clone(),llm: state.llm.clone(),auto_improve_require_approval: false,+ auto_improve_review_config: Default::default(),embedder: state.embedder.clone(),provider_health: state.provider_health.clone(),decay_params: state.decay_params,diff --git a/crates/ai-memory-mcp/tests/admin_status_search.rs b/crates/ai-memory-mcp/tests/admin_status_search.rsindex 8f23ad67..9287a28a 100644--- a/crates/ai-memory-mcp/tests/admin_status_search.rs+++ b/crates/ai-memory-mcp/tests/admin_status_search.rs@@ -23,6 +23,7 @@ async fn make_admin_state(tmp: &TempDir) -> (AdminState, Store) {wiki,llm: None,auto_improve_require_approval: false,+ auto_improve_review_config: Default::default(),embedder: None,provider_health: ai_memory_llm::ProviderHealth::default(),decay_params: DecayParams::default(),diff --git a/crates/ai-memory-mcp/tests/admin_write_page.rs b/crates/ai-memory-mcp/tests/admin_write_page.rsindex d3b5519f..8685fa5b 100644--- a/crates/ai-memory-mcp/tests/admin_write_page.rs+++ b/crates/ai-memory-mcp/tests/admin_write_page.rs@@ -23,6 +23,7 @@ async fn make_state(tmp: &TempDir) -> AdminState {wiki,llm: None,auto_improve_require_approval: false,+ auto_improve_review_config: Default::default(),embedder: None,provider_health: ai_memory_llm::ProviderHealth::default(),decay_params: DecayParams::default(),diff --git a/crates/ai-memory-store/migrations/V23__auto_improve_patch_proposals.sql b/crates/ai-memory-store/migrations/V23__auto_improve_patch_proposals.sqlnew file mode 100644index 00000000..c473d8d1--- /dev/null+++ b/crates/ai-memory-store/migrations/V23__auto_improve_patch_proposals.sql@@ -0,0 +1,14 @@+-- Add patch proposal metadata while preserving existing full-page rows.++ALTER TABLE auto_improve_proposals+ ADD COLUMN edit_mode TEXT NOT NULL DEFAULT 'full_page'+ CHECK (edit_mode IN ('full_page','patch'));++ALTER TABLE auto_improve_proposals+ ADD COLUMN patch_json TEXT;++ALTER TABLE auto_improve_proposals+ ADD COLUMN expected_base_body_sha256 BLOB;++ALTER TABLE auto_improve_proposals+ ADD COLUMN materialized_base_body_sha256 BLOB;diff --git a/crates/ai-memory-store/migrations/V24__auto_improve_rejections.sql b/crates/ai-memory-store/migrations/V24__auto_improve_rejections.sqlnew file mode 100644index 00000000..5c771d21--- /dev/null+++ b/crates/ai-memory-store/migrations/V24__auto_improve_rejections.sql@@ -0,0 +1,34 @@+-- Persistent rejection buffer for auto-improvement review feedback.++CREATE TABLE auto_improve_rejections (+ id BLOB PRIMARY KEY NOT NULL,+ workspace_id BLOB NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,+ project_id BLOB NOT NULL REFERENCES projects(id) ON DELETE CASCADE,+ target_path TEXT,+ kind TEXT,+ operation TEXT,+ edit_mode TEXT,+ reason TEXT NOT NULL,+ normalized_fingerprint TEXT NOT NULL,+ summary TEXT NOT NULL,+ evidence_json TEXT NOT NULL DEFAULT '{}',+ source_run_id BLOB REFERENCES auto_improve_runs(id) ON DELETE SET NULL,+ source_proposal_id BLOB REFERENCES auto_improve_proposals(id) ON DELETE SET NULL,+ created_at INTEGER NOT NULL+);++CREATE INDEX idx_auto_improve_rejections_scope_recent+ ON auto_improve_rejections(workspace_id, project_id, created_at DESC);+CREATE INDEX idx_auto_improve_rejections_scope_fingerprint+ ON auto_improve_rejections(workspace_id, project_id, normalized_fingerprint, created_at DESC);+CREATE INDEX idx_auto_improve_rejections_scope_path_recent+ ON auto_improve_rejections(workspace_id, project_id, target_path, created_at DESC)+ WHERE target_path IS NOT NULL;++CREATE TRIGGER auto_improve_rejections_ws_proj_pairing_ai+BEFORE INSERT ON auto_improve_rejections+FOR EACH ROW+WHEN NEW.workspace_id IS NOT (SELECT workspace_id FROM projects WHERE id = NEW.project_id)+BEGIN+ SELECT RAISE(ABORT, 'auto_improve_rejections.workspace_id does not match the project''s workspace');+END;diff --git a/crates/ai-memory-store/src/auto_improve.rs b/crates/ai-memory-store/src/auto_improve.rsindex f428fb68..8032418a 100644--- a/crates/ai-memory-store/src/auto_improve.rs+++ b/crates/ai-memory-store/src/auto_improve.rs@@ -10,6 +10,7 @@ use jiff::Timestamp;use rusqlite::{Connection, OptionalExtension, Row, params};use serde::{Deserialize, Serialize};use sha2::{Digest, Sha256};+use uuid::Uuid;use crate::error::{StoreError, StoreResult};use crate::ops;@@ -107,6 +108,9 @@ pub struct NewAutoImproveProposal {pub evidence_json: serde_json::Value,pub body_markdown: String,pub artifact_sha256: Option<[u8; 32]>,+ pub edit_mode: Option<String>,+ pub patch_json: Option<serde_json::Value>,+ pub expected_base_body_sha256: Option<[u8; 32]>,}#[derive(Debug, Clone, Serialize)]@@ -148,6 +152,10 @@ pub struct AutoImproveProposalDetail {pub decided_by_actor_json: Option<serde_json::Value>,pub applied_page_id: Option<PageId>,pub checkpoint: Option<String>,+ pub edit_mode: String,+ pub patch_json: Option<serde_json::Value>,+ pub expected_base_body_sha256: Option<[u8; 32]>,+ pub materialized_base_body_sha256: Option<[u8; 32]>,pub events: Vec<AutoImproveProposalEvent>,}@@ -162,6 +170,24 @@ pub struct AutoImproveProposalEvent {pub at: i64,}+#[derive(Debug, Clone, Serialize)]+pub struct AutoImproveRejectionSummary {+ pub id: String,+ pub workspace_id: WorkspaceId,+ pub project_id: ProjectId,+ pub target_path: Option<String>,+ pub kind: Option<String>,+ pub operation: Option<String>,+ pub edit_mode: Option<String>,+ pub reason: String,+ pub normalized_fingerprint: String,+ pub summary: String,+ pub evidence_json: serde_json::Value,+ pub source_run_id: Option<AutoImproveRunId>,+ pub source_proposal_id: Option<AutoImproveProposalId>,+ pub created_at: i64,+}+#[derive(Debug, Clone)]pub struct RejectAutoImproveProposal {pub workspace_id: WorkspaceId,@@ -326,12 +352,19 @@ pub fn stage_run(now,],)?;+ insert_rejected_candidates_in_tx(&tx, input, run_id, now)?;let mut proposal_ids = Vec::with_capacity(input.proposals.len());for proposal in &input.proposals {let id = AutoImproveProposalId::new();let artifact_path = artifact_path_for(id);let evidence_json = serde_json::to_string(&proposal.evidence_json)?;let body_sha256 = sha256(proposal.body_markdown.as_bytes());+ let edit_mode = proposal.edit_mode.as_deref().unwrap_or("full_page");+ let patch_json = proposal+ .patch_json+ .as_ref()+ .map(serde_json::to_string)+ .transpose()?;let target_snapshot = latest_target_snapshot(&tx,input.workspace_id,@@ -360,14 +393,50 @@ pub fn stage_run()));}};+ if edit_mode == "patch" {+ if proposal.operation != AutoImproveProposalOperation::Update {+ return Err(StoreError::InvalidState(format!(+ "patch proposal must use update operation: {}",+ proposal.target_path+ )));+ }+ if patch_json.is_none() {+ return Err(StoreError::InvalidState(format!(+ "patch proposal missing patch_json: {}",+ proposal.target_path+ )));+ }+ let Some(expected) = proposal.expected_base_body_sha256 else {+ return Err(StoreError::InvalidState(format!(+ "patch proposal missing expected base body hash: {}",+ proposal.target_path+ )));+ };+ match target_body_sha256_at_stage {+ Some(current) if current == expected => {}+ Some(_) => {+ return Err(StoreError::InvalidState(format!(+ "auto-improve proposal target changed since patch materialization: {}",+ proposal.target_path+ )));+ }+ None => {+ return Err(StoreError::InvalidState(format!(+ "patch proposal target does not exist: {}",+ proposal.target_path+ )));+ }+ }+ }tx.execute("INSERT INTO auto_improve_proposals \(id, run_id, workspace_id, project_id, status, operation, target_path, kind, title, \confidence, rationale, evidence_json, body_markdown, body_sha256, artifact_path, \artifact_sha256, target_latest_page_id_at_stage, target_body_sha256_at_stage, \- target_updated_at_at_stage, staged_at) \+ target_updated_at_at_stage, staged_at, edit_mode, patch_json, \+ expected_base_body_sha256, materialized_base_body_sha256) \VALUES (?1, ?2, ?3, ?4, 'pending', ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14, \- ?15, ?16, ?17, ?18, ?19)",+ ?15, ?16, ?17, ?18, ?19, ?20, ?21, ?22, ?23)",params![id.as_bytes(),run_id.as_bytes(),@@ -388,6 +457,10 @@ pub fn stage_run(target_body_sha256_at_stage.map(|h| h.to_vec()),target_updated_at_at_stage,now,+ edit_mode,+ patch_json,+ proposal.expected_base_body_sha256.map(|h| h.to_vec()),+ proposal.expected_base_body_sha256.map(|h| h.to_vec()),],)?;insert_event_in_tx(@@ -432,6 +505,7 @@ pub fn fail_proposal(conn: &mut Connection, input: &FailAutoImproveProposal) ->"auto-improve proposal is not pending or not in scope".into(),));}+ insert_rejection_for_proposal_in_tx(&tx, input.proposal_id, &input.reason, now)?;insert_event_in_tx(&tx,input.proposal_id,@@ -472,6 +546,7 @@ pub fn reject_proposal("auto-improve proposal is not pending or not in scope".into(),));}+ insert_rejection_for_proposal_in_tx(&tx, input.proposal_id, &input.reason, now)?;insert_event_in_tx(&tx,input.proposal_id,@@ -549,6 +624,12 @@ pub fn approve_proposal(},};if conflict {+ insert_rejection_for_proposal_in_tx(+ &tx,+ input.proposal_id,+ "target changed since proposal was staged",+ now,+ )?;mark_decision_in_tx(&tx,input,@@ -663,6 +744,180 @@ fn insert_event_in_tx(Ok(())}+fn insert_rejected_candidates_in_tx(+ tx: &rusqlite::Transaction<'_>,+ input: &StageAutoImproveRun,+ run_id: AutoImproveRunId,+ now: i64,+) -> StoreResult<()> {+ let Some(candidates) = input.rejected_candidates_json.as_array() else {+ return Ok(());+ };+ for candidate in candidates {+ let reason = candidate+ .get("reason")+ .and_then(serde_json::Value::as_str)+ .unwrap_or("")+ .trim();+ if reason.is_empty() {+ continue;+ }+ let target_path = string_field(candidate, "target_path")+ .or_else(|| string_field(candidate, "path"))+ .or_else(|| {+ string_field(candidate, "evidence").filter(|value| PagePath::new(value).is_ok())+ });+ let summary = string_field(candidate, "summary")+ .or_else(|| string_field(candidate, "evidence"))+ .unwrap_or_else(|| reason.to_string());+ let record = NewAutoImproveRejectionRecord {+ workspace_id: input.workspace_id,+ project_id: input.project_id,+ target_path,+ kind: string_field(candidate, "kind"),+ operation: string_field(candidate, "operation"),+ edit_mode: string_field(candidate, "edit_mode"),+ reason: reason.to_string(),+ summary,+ evidence_json: candidate.clone(),+ source_run_id: Some(run_id),+ source_proposal_id: None,+ };+ insert_rejection_record_in_tx(tx, &record, now)?;+ }+ Ok(())+}++fn string_field(value: &serde_json::Value, key: &str) -> Option<String> {+ value+ .get(key)+ .and_then(serde_json::Value::as_str)+ .map(str::trim)+ .filter(|s| !s.is_empty())+ .map(ToOwned::to_owned)+}++struct NewAutoImproveRejectionRecord {+ workspace_id: WorkspaceId,+ project_id: ProjectId,+ target_path: Option<String>,+ kind: Option<String>,+ operation: Option<String>,+ edit_mode: Option<String>,+ reason: String,+ summary: String,+ evidence_json: serde_json::Value,+ source_run_id: Option<AutoImproveRunId>,+ source_proposal_id: Option<AutoImproveProposalId>,+}++fn insert_rejection_for_proposal_in_tx(+ tx: &rusqlite::Transaction<'_>,+ proposal_id: AutoImproveProposalId,+ reason: &str,+ now: i64,+) -> StoreResult<()> {+ let record = tx.query_row(+ "SELECT run_id, workspace_id, project_id, operation, target_path, kind, title, rationale, \+ evidence_json, edit_mode \+ FROM auto_improve_proposals WHERE id = ?1",+ params![proposal_id.as_bytes()],+ |row| {+ let run_id =+ AutoImproveRunId::from_slice(&row.get::<_, Vec<u8>>(0)?).map_err(to_sql_err)?;+ let workspace_id =+ WorkspaceId::from_slice(&row.get::<_, Vec<u8>>(1)?).map_err(to_sql_err)?;+ let project_id =+ ProjectId::from_slice(&row.get::<_, Vec<u8>>(2)?).map_err(to_sql_err)?;+ let evidence_raw: String = row.get(8)?;+ let title: String = row.get(6)?;+ let rationale: String = row.get(7)?;+ Ok(NewAutoImproveRejectionRecord {+ workspace_id,+ project_id,+ target_path: Some(row.get(4)?),+ kind: Some(row.get(5)?),+ operation: Some(row.get(3)?),+ edit_mode: Some(row.get(9)?),+ reason: reason.to_string(),+ summary: if title.trim().is_empty() {+ rationale+ } else {+ title+ },+ evidence_json: serde_json::from_str(&evidence_raw).map_err(to_sql_err)?,+ source_run_id: Some(run_id),+ source_proposal_id: Some(proposal_id),+ })+ },+ )?;+ insert_rejection_record_in_tx(tx, &record, now)+}++fn insert_rejection_record_in_tx(+ tx: &rusqlite::Transaction<'_>,+ record: &NewAutoImproveRejectionRecord,+ now: i64,+) -> StoreResult<()> {+ let id = Uuid::new_v4();+ let evidence_json = serde_json::to_string(&record.evidence_json)?;+ let fingerprint = rejection_fingerprint(record);+ tx.execute(+ "INSERT INTO auto_improve_rejections \+ (id, workspace_id, project_id, target_path, kind, operation, edit_mode, reason, \+ normalized_fingerprint, summary, evidence_json, source_run_id, source_proposal_id, created_at) \+ VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14)",+ params![+ id.as_bytes().as_slice(),+ record.workspace_id.as_bytes(),+ record.project_id.as_bytes(),+ record.target_path.as_deref(),+ record.kind.as_deref(),+ record.operation.as_deref(),+ record.edit_mode.as_deref(),+ record.reason.as_str(),+ fingerprint,+ record.summary.as_str(),+ evidence_json,+ record.source_run_id.map(|id| id.as_bytes().to_vec()),+ record.source_proposal_id.map(|id| id.as_bytes().to_vec()),+ now,+ ],+ )?;+ Ok(())+}++fn rejection_fingerprint(record: &NewAutoImproveRejectionRecord) -> String {+ let input = [+ normalize_fp(record.target_path.as_deref().unwrap_or("")),+ normalize_fp(record.kind.as_deref().unwrap_or("")),+ normalize_fp(record.operation.as_deref().unwrap_or("")),+ normalize_fp(record.edit_mode.as_deref().unwrap_or("")),+ normalize_fp(&record.reason),+ normalize_fp(&record.summary),+ ]+ .join("\n");+ hex_sha256(input.as_bytes())+}++fn normalize_fp(value: &str) -> String {+ value+ .split_whitespace()+ .collect::<Vec<_>>()+ .join(" ")+ .to_ascii_lowercase()+}++fn hex_sha256(bytes: &[u8]) -> String {+ let hash = Sha256::digest(bytes);+ let mut out = String::with_capacity(64);+ for byte in hash {+ use std::fmt::Write as _;+ let _ = write!(&mut out, "{byte:02x}");+ }+ out+}+fn sha256(bytes: &[u8]) -> [u8; 32] {let mut hasher = Sha256::new();hasher.update(bytes);diff --git a/crates/ai-memory-store/src/lib.rs b/crates/ai-memory-store/src/lib.rsindex 3c03e02e..4a9cb736 100644--- a/crates/ai-memory-store/src/lib.rs+++ b/crates/ai-memory-store/src/lib.rs@@ -28,8 +28,9 @@ pub use fts_query::prepare_fts5_query;pub use auto_improve::{ApproveAutoImproveProposal, ApproveAutoImproveProposalResult, AutoImproveProposalDetail,AutoImproveProposalEvent, AutoImproveProposalOperation, AutoImproveProposalStatus,- AutoImproveProposalSummary, FailAutoImproveProposal, NewAutoImproveProposal,- RejectAutoImproveProposal, StageAutoImproveRun, StagedAutoImproveRun, artifact_path_for,+ AutoImproveProposalSummary, AutoImproveRejectionSummary, FailAutoImproveProposal,+ NewAutoImproveProposal, RejectAutoImproveProposal, StageAutoImproveRun, StagedAutoImproveRun,+ artifact_path_for,};pub use decay::{DecayParams, retention_score};pub use error::{StoreError, StoreResult};@@ -146,6 +147,9 @@ mod tests {evidence_json: serde_json::json!([{"source":"test"}]),body_markdown: body.into(),artifact_sha256: None,+ edit_mode: None,+ patch_json: None,+ expected_base_body_sha256: None,}}@@ -253,6 +257,9 @@ mod tests {.unwrap().unwrap();assert_eq!(detail.events.len(), 1);+ assert_eq!(detail.edit_mode, "full_page");+ assert!(detail.patch_json.is_none());+ assert!(detail.expected_base_body_sha256.is_none());assert_eq!(detail.artifact_path,format!("_pending/auto-improve/{}.md", staged.proposal_ids[0])@@ -331,6 +338,16 @@ mod tests {assert_eq!(detail.summary.status, AutoImproveProposalStatus::Rejected);assert_eq!(detail.decision_reason.as_deref(), Some("nope"));assert_eq!(detail.events.last().unwrap().event, "rejected");+ let rejections = store+ .reader+ .recent_auto_improve_rejections(ws, proj, 10, None)+ .await+ .unwrap();+ assert_eq!(rejections.len(), 1);+ assert_eq!(rejections[0].target_path.as_deref(), Some("notes/r.md"));+ assert_eq!(rejections[0].reason, "nope");+ assert_eq!(rejections[0].source_proposal_id, Some(id));+ assert_eq!(rejections[0].normalized_fingerprint.len(), 64);assert!(store.writer@@ -347,6 +364,65 @@ mod tests {);}+ #[tokio::test]+ async fn auto_improve_old_pending_proposal_survives_rejection_buffer_migration() {+ let tmp = TempDir::new().unwrap();+ let db_dir = tmp.path().join("db");+ std::fs::create_dir_all(&db_dir).unwrap();+ let db_path = db_dir.join(DB_FILENAME);+ let mut conn = Connection::open(&db_path).unwrap();+ migrations::run_to(&mut conn, 23).unwrap();+ let ws = ops::get_or_create_workspace(&mut conn, "default").unwrap();+ let proj = ops::get_or_create_project(&mut conn, &ws, "app", None).unwrap();+ let id = auto_improve::stage_run(+ &mut conn,+ &stage_input(+ ws,+ proj,+ vec![proposal(+ "notes/old.md",+ AutoImproveProposalOperation::Create,+ "old",+ )],+ ),+ )+ .unwrap()+ .proposal_ids[0];+ drop(conn);++ let store = Store::open(tmp.path()).unwrap();+ store+ .writer+ .reject_auto_improve_proposal(RejectAutoImproveProposal {+ workspace_id: ws,+ project_id: proj,+ proposal_id: id,+ reason: "old pending still rejectable".into(),+ actor: ActorContext::default(),+ author_id: None,+ })+ .await+ .unwrap();++ let detail = store+ .reader+ .auto_improve_proposal_detail(ws, proj, id)+ .await+ .unwrap()+ .unwrap();+ assert_eq!(detail.summary.status, AutoImproveProposalStatus::Rejected);+ assert_eq!(detail.edit_mode, "full_page");+ assert_eq!(+ store+ .reader+ .recent_auto_improve_rejections(ws, proj, 10, None)+ .await+ .unwrap()+ .len(),+ 1+ );+ }+#[tokio::test]async fn auto_improve_stage_derives_snapshots_and_validates_sessions() {let tmp = TempDir::new().unwrap();@@ -492,6 +568,60 @@ mod tests {);}+ #[tokio::test]+ async fn auto_improve_stage_persists_validator_rejections_with_scope_isolation() {+ 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, "app", None)+ .await+ .unwrap();+ let other = store+ .writer+ .get_or_create_project(ws, "other", None)+ .await+ .unwrap();++ let mut input = stage_input(ws, proj, Vec::new());+ input.rejected_candidates_json = serde_json::json!([{+ "reason": "duplicate_existing_path",+ "evidence": "notes/repeat.md",+ "target_path": "notes/repeat.md",+ "kind": "note",+ "operation": "create_or_update",+ "edit_mode": "full_page"+ }]);+ let staged = store.writer.stage_auto_improve_run(input).await.unwrap();++ let rejections = store+ .reader+ .recent_auto_improve_rejections(ws, proj, 10, None)+ .await+ .unwrap();+ assert_eq!(rejections.len(), 1);+ assert_eq!(+ rejections[0].target_path.as_deref(),+ Some("notes/repeat.md")+ );+ assert_eq!(rejections[0].kind.as_deref(), Some("note"));+ assert_eq!(rejections[0].source_run_id, Some(staged.run_id));+ assert_eq!(rejections[0].source_proposal_id, None);+ assert!(+ store+ .reader+ .recent_auto_improve_rejections(ws, other, 10, None)+ .await+ .unwrap()+ .is_empty()+ );+ }+#[tokio::test]async fn auto_improve_fail_pending_only_records_event() {let tmp = TempDir::new().unwrap();@@ -544,6 +674,14 @@ mod tests {.unwrap();assert_eq!(detail.summary.status, AutoImproveProposalStatus::Failed);assert_eq!(detail.events.last().unwrap().event, "failed");+ let rejections = store+ .reader+ .recent_auto_improve_rejections(ws, proj, 10, None)+ .await+ .unwrap();+ assert_eq!(rejections.len(), 1);+ assert_eq!(rejections[0].target_path.as_deref(), Some("notes/fail.md"));+ assert_eq!(rejections[0].reason, "admission denied");assert!(store.writer@@ -662,6 +800,16 @@ mod tests {.await.unwrap();assert_eq!(conflict, ApproveAutoImproveProposalResult::Conflict);+ let rejections = store+ .reader+ .recent_auto_improve_rejections(ws, proj, 10, None)+ .await+ .unwrap();+ assert!(rejections.iter().any(|rejection| {+ rejection.target_path.as_deref() == Some("notes/existing.md")+ && rejection.reason == "target changed since proposal was staged"+ && rejection.source_proposal_id == Some(stale_create)+ }));assert_eq!(store.reader@@ -729,6 +877,107 @@ mod tests {);}+ #[tokio::test]+ async fn auto_improve_stage_rejects_patch_base_hash_mismatch() {+ 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, "app", None)+ .await+ .unwrap();+ store+ .writer+ .upsert_page(sample_page(ws, proj, "procedures/release.md", "old"))+ .await+ .unwrap();+ let mut patch = proposal(+ "procedures/release.md",+ AutoImproveProposalOperation::Update,+ "new",+ );+ patch.edit_mode = Some("patch".into());+ patch.patch_json =+ Some(serde_json::json!([{ "op": "append", "anchor": "## Steps", "content": "new" }]));+ patch.expected_base_body_sha256 = Some(sha256("different old body"));++ let err = store+ .writer+ .stage_auto_improve_run(stage_input(ws, proj, vec![patch]))+ .await+ .unwrap_err();+ assert!(+ err.to_string()+ .contains("target changed since patch materialization")+ );+ assert!(+ store+ .reader+ .list_auto_improve_proposals(ws, proj, None, 10)+ .await+ .unwrap()+ .is_empty()+ );+ }++ #[tokio::test]+ async fn auto_improve_stage_rejects_patch_missing_base_hash_and_create() {+ 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, "app", None)+ .await+ .unwrap();+ store+ .writer+ .upsert_page(sample_page(ws, proj, "procedures/release.md", "old"))+ .await+ .unwrap();++ let mut missing_hash = proposal(+ "procedures/release.md",+ AutoImproveProposalOperation::Update,+ "new",+ );+ missing_hash.edit_mode = Some("patch".into());+ missing_hash.patch_json = Some(serde_json::json!([{ "op": "append" }]));+ let err = store+ .writer+ .stage_auto_improve_run(stage_input(ws, proj, vec![missing_hash]))+ .await+ .unwrap_err();+ assert!(err.to_string().contains("missing expected base body hash"));++ let mut create_patch = proposal(+ "procedures/new.md",+ AutoImproveProposalOperation::Create,+ "new",+ );+ create_patch.edit_mode = Some("patch".into());+ create_patch.patch_json = Some(serde_json::json!([{ "op": "append" }]));+ create_patch.expected_base_body_sha256 = Some(sha256("old"));+ let err = store+ .writer+ .stage_auto_improve_run(stage_input(ws, proj, vec![create_patch]))+ .await+ .unwrap_err();+ assert!(+ err.to_string()+ .contains("patch proposal must use update operation")+ );+ }+#[tokio::test]async fn auto_improve_approval_rejects_mismatched_page_author() {let tmp = TempDir::new().unwrap();diff --git a/crates/ai-memory-store/src/reader.rs b/crates/ai-memory-store/src/reader.rsindex dbb19bb3..a9d7fd38 100644--- a/crates/ai-memory-store/src/reader.rs+++ b/crates/ai-memory-store/src/reader.rs@@ -11,21 +11,24 @@ use std::path::{Path, PathBuf};use std::sync::Arc;use ai_memory_core::{- AgentKind, AutoImproveProposalId, Handoff, HandoffId, HandoffState, Observation, ObservationId,- ObservationKind, PageId, PagePath, ProjectId, SessionId, User, UserId, WorkspaceId,+ AgentKind, AutoImproveProposalId, AutoImproveRunId, Handoff, HandoffId, HandoffState,+ Observation, ObservationId, ObservationKind, PageId, PagePath, ProjectId, SessionId, User,+ UserId, WorkspaceId,};use jiff::Timestamp;use parking_lot::Mutex;use rusqlite::types::Value;use rusqlite::{Connection, OpenFlags, OptionalExtension, params, params_from_iter};use serde::Serialize;+use uuid::Uuid;// `ai_memory_core::Tier` is referenced via fully-qualified path inside the// DecayCandidate struct definition above to avoid a top-level import// for a single use-site.use crate::auto_improve::{AutoImproveProposalDetail, AutoImproveProposalEvent, AutoImproveProposalStatus,- AutoImproveProposalSummary, bytes32, opt_bytes32, summary_from_row, to_sql_err,+ AutoImproveProposalSummary, AutoImproveRejectionSummary, bytes32, opt_bytes32,+ summary_from_row, to_sql_err,};use crate::error::{StoreError, StoreResult};use crate::fts_query::prepare_fts5_query;@@ -3104,7 +3107,8 @@ impl ReaderPool {artifact_sha256, target_latest_page_id_at_stage, \target_body_sha256_at_stage, target_updated_at_at_stage, \decision_reason, decided_by_author_id, decided_by_actor_json, \- applied_page_id, checkpoint \+ applied_page_id, checkpoint, edit_mode, patch_json, \+ expected_base_body_sha256, materialized_base_body_sha256 \FROM auto_improve_proposals \WHERE id = ?1 AND workspace_id = ?2 AND project_id = ?3",params![@@ -3134,6 +3138,7 @@ impl ReaderPool {.map(|b| PageId::from_slice(&b)).transpose().map_err(to_sql_err)?;+ let patch_raw: Option<String> = row.get(27)?;Ok(AutoImproveProposalDetail {summary,rationale: row.get(12)?,@@ -3154,6 +3159,15 @@ impl ReaderPool {.map_err(to_sql_err)?,applied_page_id,checkpoint: row.get(25)?,+ edit_mode: row.get(26)?,+ patch_json: patch_raw+ .map(|raw| serde_json::from_str(&raw))+ .transpose()+ .map_err(to_sql_err)?,+ expected_base_body_sha256: opt_bytes32(row.get(28)?)+ .map_err(to_sql_err)?,+ materialized_base_body_sha256: opt_bytes32(row.get(29)?)+ .map_err(to_sql_err)?,events: Vec::new(),})},@@ -3195,6 +3209,72 @@ impl ReaderPool {.await}+ /// Read recent rejection-buffer entries for one workspace/project scope.+ pub async fn recent_auto_improve_rejections(+ &self,+ workspace_id: WorkspaceId,+ project_id: ProjectId,+ limit: usize,+ since_created_at: Option<i64>,+ ) -> StoreResult<Vec<AutoImproveRejectionSummary>> {+ self.with_conn(move |conn| {+ let limit = i64::try_from(limit).unwrap_or(i64::MAX);+ let since = since_created_at.unwrap_or(0);+ let mut stmt = conn.prepare(+ "SELECT id, workspace_id, project_id, target_path, kind, operation, edit_mode, \+ reason, normalized_fingerprint, summary, evidence_json, source_run_id, \+ source_proposal_id, created_at \+ FROM auto_improve_rejections \+ WHERE workspace_id = ?1 AND project_id = ?2 AND created_at >= ?3 \+ ORDER BY created_at DESC LIMIT ?4",+ )?;+ let rows = stmt.query_map(+ params![workspace_id.as_bytes(), project_id.as_bytes(), since, limit],+ |row| {+ let id_bytes: Vec<u8> = row.get(0)?;+ let id = Uuid::from_slice(&id_bytes).map_err(to_sql_err)?.to_string();+ let workspace_id =+ WorkspaceId::from_slice(&row.get::<_, Vec<u8>>(1)?).map_err(to_sql_err)?;+ let project_id =+ ProjectId::from_slice(&row.get::<_, Vec<u8>>(2)?).map_err(to_sql_err)?;+ let evidence_raw: String = row.get(10)?;+ let source_run_id = row+ .get::<_, Option<Vec<u8>>>(11)?+ .map(|b| AutoImproveRunId::from_slice(&b))+ .transpose()+ .map_err(to_sql_err)?;+ let source_proposal_id = row+ .get::<_, Option<Vec<u8>>>(12)?+ .map(|b| AutoImproveProposalId::from_slice(&b))+ .transpose()+ .map_err(to_sql_err)?;+ Ok(AutoImproveRejectionSummary {+ id,+ workspace_id,+ project_id,+ target_path: row.get(3)?,+ kind: row.get(4)?,+ operation: row.get(5)?,+ edit_mode: row.get(6)?,+ reason: row.get(7)?,+ normalized_fingerprint: row.get(8)?,+ summary: row.get(9)?,+ evidence_json: serde_json::from_str(&evidence_raw).map_err(to_sql_err)?,+ source_run_id,+ source_proposal_id,+ created_at: row.get(13)?,+ })+ },+ )?;+ let mut out = Vec::new();+ for row in rows {+ out.push(row?);+ }+ Ok(out)+ })+ .await+ }+/// Look up a workspace id by name without creating it.////// Returns `None` when no workspace with the given name exists.diff --git a/crates/ai-memory-wiki/src/wiki.rs b/crates/ai-memory-wiki/src/wiki.rsindex fe587097..06947204 100644--- a/crates/ai-memory-wiki/src/wiki.rs+++ b/crates/ai-memory-wiki/src/wiki.rs@@ -1366,6 +1366,16 @@ fn canonicalize_index_frontmatter(fn render_auto_improve_sidecar(detail: &AutoImproveProposalDetail) -> WikiResult<String> {let evidence = serde_json::to_string_pretty(&detail.evidence_json)?;+ let patch = detail+ .patch_json+ .as_ref()+ .map(serde_json::to_string_pretty)+ .transpose()?+ .unwrap_or_else(|| "null".into());+ let expected_base = detail+ .expected_base_body_sha256+ .map(|hash| hash.iter().map(|b| format!("{b:02x}")).collect::<String>())+ .unwrap_or_else(|| "none".into());Ok(format!("# Pending auto-improvement proposal\n\n\- proposal_id: `{}`\n\@@ -1376,9 +1386,12 @@ fn render_auto_improve_sidecar(detail: &AutoImproveProposalDetail) -> WikiResult- kind: `{}`\n\- title: `{}`\n\- confidence: `{}`\n\+ - edit_mode: `{}`\n\+ - expected_base_body_sha256: `{}`\n\- staged_at: `{}`\n\n\## Rationale\n\n{}\n\n\## Evidence\n\n```json\n{}\n```\n\n\+ ## Patch metadata\n\n```json\n{}\n```\n\n\## Proposed body\n\n{}\n",detail.summary.id,detail.summary.run_id,@@ -1388,9 +1401,12 @@ fn render_auto_improve_sidecar(detail: &AutoImproveProposalDetail) -> WikiResultdetail.summary.kind,detail.summary.title,detail.summary.confidence,+ detail.edit_mode,+ expected_base,detail.summary.staged_at,detail.rationale,evidence,+ patch,detail.body_markdown,))}@@ -1663,6 +1679,9 @@ mod tests {evidence_json: serde_json::json!([{ "source": "test" }]),body_markdown: body.into(),artifact_sha256: None,+ edit_mode: None,+ patch_json: None,+ expected_base_body_sha256: None,}}diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.mdindex 5d6a9f17..c73437a6 100644--- a/docs/ARCHITECTURE.md+++ b/docs/ARCHITECTURE.md@@ -36,7 +36,10 @@ non-overlapping; long all-project review passes delay the next tick instead ofstarting 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 proposals-pending for review.+pending for review. Operators can additionally set `[auto_improve.eval]` to run+a project-supplied executable gate for selected proposal prefixes after LLM+validation and before staging/approval; it is disabled by default and never runs+from hook paths.**Steady-state loop:**@@ -70,7 +73,10 @@ pending for review.not retry forever. Explicit CLI/admin/MCP auto-improve calls use the samepipeline for targeted reruns or catch-up. With `[auto_improve]require_approval = true`, scheduled and manual proposals remain pending until- explicit pending-writes approval.+ explicit pending-writes approval. If `[auto_improve.eval] enabled = true`,+ targeted proposals (default `_rules/` and `procedures/`) must pass the+ configured executable JSON contract before they are staged; failures become+ rejected candidates/rejection-buffer entries rather than wiki writes.6. `memory_query` answers via FTS5 + link-neighbour RRF; when anembedder is configured, vector cosine over `page_embeddings` joinsthe same RRF. If compiled wiki pages miss entirely, bounded raw@@ -335,6 +341,17 @@ min_session_duration_secs = 120min_confidence = 0.75max_input_tokens = 24000max_proposals_per_run = 5+max_patchable_pages = 8+max_patchable_body_chars = 8000+max_edits_per_proposal = 5+max_edit_content_chars = 4000+max_changed_chars_per_proposal = 12000+max_patch_edits_per_run = 8+max_rejection_context = 50+rejection_context_days = 180+max_final_body_chars = 32000+max_rule_page_tokens = 2000+max_procedure_page_tokens = 2000include_raw_fallback = falseproposal_actor = "auto_improve"pending_path = "_pending/auto-improve"diff --git a/docs/auto-improve-skillopt-roadmap.md b/docs/auto-improve-skillopt-roadmap.mdnew file mode 100644index 00000000..85183311--- /dev/null+++ b/docs/auto-improve-skillopt-roadmap.md@@ -0,0 +1,283 @@+# Auto-Improve SkillOpt-Inspired Roadmap++This is the ongoing implementation plan for borrowing the best safety ideas from+SkillOpt without turning ai-memory into a workflow manager, benchmark harness, or+agent orchestration platform.++## Boundary++ai-memory remains a memory substrate:++- automatic capture from lifecycle hooks;+- markdown wiki as the source of truth;+- SQLite as the derived index and audit store;+- small, auditable wiki proposals through pending-writes;+- optional LLM review outside hook latency.++This roadmap does **not** add a spec-driven workflow, mandatory task scoring,+agent replay engine, skill router, code graph, or benchmark registry.++## Why this work matters++The current auto-improvement loop validates proposals structurally: path, kind,+confidence, evidence, size, duplicate checks, and approval policy. That is useful+but not enough for high-impact pages such as `_rules/` and `procedures/`, where a+bad edit can shape future agent behavior. The biggest wins are to make proposed+changes smaller, easier to review, harder to repeat after rejection, and optionally+measurable when a project supplies its own scoring command.++## Invariants++- Existing full-page `create_or_update` proposals must continue to validate,+ stage, diff, approve, reject, and audit.+- New behavior must be additive migrations/config; existing installs keep the+ same defaults.+- Target wiki mutations must still pass through `Wiki::write_page`,+ `Wiki::apply_batch`, or existing approval helpers.+- Server/admin/MCP paths must preserve `ScopeResolver` and+ `AuthLevel::authorize(Capability::...)` boundaries.+- Hooks must remain fire-and-forget and must not run LLM review, patching, or+ evaluation gates.+- No new public MCP tool surface unless the existing `memory_auto_improve` and+ pending-writes surface cannot express the workflow.++## Phase 1 — Structured Patch Proposals With Minimal Budgets++Add patch proposals as a backwards-compatible extension to the existing proposal+shape. Full-page bodies remain supported forever, especially for new pages.++Preferred update mode for `_rules/` and `procedures/` should become small+structured patches, but only when the reviewer has enough target-page context to+name stable anchors. Full-page proposals still must not overwrite existing+semantic/procedural pages; patch proposals require an existing target page.++```json+{+ "edit_mode": "patch",+ "edits": [+ {"op": "append", "anchor": "## Release process", "content": "..."},+ {"op": "replace_section", "anchor": "## Gotchas", "content": "..."}+ ]+}+```++Initial supported operations:++- `add_section`+- `append`+- `replace_section` only with section hash/context verification++`delete_section` is deferred. If it is later added, it must either be excluded+from auto-approval or force manual approval even when global auto-approve is+enabled.++Patch semantics:++- Anchors use exact markdown heading text, including marker, e.g.+ `## Release process`.+- Anchors must be unique after normalized whitespace comparison; duplicate+ anchors reject.+- H1 replacement/deletion is not supported.+- A section span starts at the anchor heading and ends before the next heading of+ equal or higher level. Child subsections are included in `replace_section`.+- `append` inserts content at the end of the anchored section before the next+ equal-or-higher heading, preserving a blank-line boundary.+- `add_section` inserts a new sibling section after the anchored section span.+- `replace_section` requires a pre-edit section hash or exact context and+ rejects if the section changed.+- Final materialized bodies must still pass the normal H1, path, kind, and size+ validation.++Minimum Phase 1 budget caps:++- max edits per proposal;+- max content chars per edit;+- max changed chars per proposal;+- max final body size.++Implementation notes:++- Materialize patches into final `body_markdown` for compatibility with the+ existing approval flow, but close the materialize-to-stage race by passing an+ expected base hash into staging and rejecting if the current target hash+ differs. Materialization may also move inside the same writer transaction if+ that proves cleaner.+- Store original patch JSON for audit/diff/debug.+- Store `edit_mode`, original `patch_json`, expected base hash, materialized+ base hash, and final body metadata through an additive migration. Existing+ rows default to full-page mode.+- Include bounded target page bodies or heading outlines for patchable `_rules/`+ and `procedures/` pages in the reviewer prompt. Do not request patches for+ pages whose anchors were not provided.+- Store target page hash at staging and reject approval if the page changed.+- Use markdown heading anchors and context/hash checks, not line-number patches.++Required tests:++- old full-page proposals still work;+- each patch operation materializes correctly;+- invalid/missing anchors reject cleanly;+- target hash conflict blocks approval;+- page changes between materialization and staging reject;+- old pending proposals remain readable and approvable after migration;+- duplicate anchors reject;+- patch to missing target rejects;+- full-page proposal to an existing non-slot page still rejects;+- destructive operations cannot auto-approve if added later;+- `_rules/` and `procedures/` reviewer instructions prefer patch mode.++## Phase 2 — Bounded Edit Budgets++Phase 1 absorbed the minimum per-proposal caps needed to ship patch proposals+safely: patchable page/context bounds, edits per proposal, edit content chars,+changed chars per proposal, and global final body chars. Phase 2 adds the+remaining run-level and page-class budgets. Defer cosine decay or maturity+schedules until there is real operational data.++Proposed config shape:++```toml+[auto_improve]+max_proposals_per_run = 5+max_patch_edits_per_proposal = 4+max_patch_edits_per_run = 8+max_changed_chars_per_proposal = 4000+max_rule_page_tokens = 2000+max_procedure_page_tokens = 2000+```++Validation rejects proposals that exceed the run-level patch edit budget or+procedural/rule final-page budgets. The earlier Phase 1 validators continue to+enforce per-proposal edit count, changed-char, edit-content, and global final+body limits.++Required tests:++- per-run patch edit limits;+- `_rules/` / `procedures/` page-budget enforcement;+- existing non-patch behavior remains unchanged except existing global limits.++## Phase 3 — Rejected Proposal Buffer++Status: implemented.++Persist useful rejection memory and feed a bounded summary into future reviewer+prompts so the model does not repeat failed edit patterns.++Proposed table:++```text+auto_improve_rejections+- id+- workspace_id+- project_id+- target_path+- kind+- operation/edit_mode+- reason+- normalized_fingerprint+- summary+- evidence_json+- source_run_id+- source_proposal_id nullable+- created_at+```++Populate from:++- validator rejects;+- human pending-writes rejects;+- approval conflicts;+- admission failures;+- future eval-gate failures.++Prompt context should include only a bounded recent subset, e.g. latest 50 per+project or 180 days. Do not add embeddings initially.++Implementation notes:++- `V24__auto_improve_rejections.sql` adds `auto_improve_rejections` with+ workspace/project pairing enforcement plus recent, fingerprint, and path+ indexes.+- Human rejects, admission failures, and approval conflicts write rejection+ records in the same decision transaction.+- Validator/model rejected candidates are persisted at run staging when a reason+ is present; target path/kind/operation/edit-mode are stored when the rejection+ carries that metadata.+- Reviewer prompts include recent same-scope rejection summaries bounded by+ `max_rejection_context` and `rejection_context_days`.++Required tests:++- human rejection creates a reusable rejection record;+- validator rejection creates a record when enough metadata is available;+- future prompts include relevant prior rejections;+- workspace/project isolation is preserved;+- old pending proposals remain approvable/rejectable.++## Phase 4 — Optional Executable Evaluation Gate++Status: implemented.++Only run when a project explicitly supplies a scoring command. Disabled means the+current validation + approval behavior is unchanged.++Proposed config:++```toml+[auto_improve.eval]+enabled = false+command = "./scripts/score-auto-improve-proposal"+timeout_secs = 120+targets = ["_rules", "procedures"]+min_delta = 0.0+```++Contract:++- ai-memory does not build a benchmark registry, replay harness, scoring DSL, or+ agent simulator;+- the external command is executed directly (not through a shell) with JSON on+ stdin containing proposal metadata plus before/after bodies;+- the command returns JSON such as+ `{ "score_before": 0.72, "score_after": 0.76, "passed": true }`;+- when scores are present, `score_after - score_before` must meet `min_delta`;+- failed, timed-out, errored, or invalid-JSON evaluations fail closed for targeted+ proposals and are recorded as rejected candidates with reasons such as+ `eval_gate_failed`, `eval_gate_timeout`, or `eval_gate_error`.++If every proposal in a run fails eval, ai-memory stages the run with zero+proposals and the eval rejections so the rejection buffer still learns from the+attempt. Non-targeted proposals bypass eval even when the gate is enabled. Hook+paths remain fire-and-forget and never run the eval command.++Non-goals:++- no replay orchestration;+- no benchmark/task registry;+- no scoring DSL;+- no agent simulator.++Required tests:++- eval disabled preserves current behavior;+- passing eval allows staging/approval;+- failing eval rejects and records rejection;+- timeout/error fail closed for eval-targeted proposals;+- eval never runs from hook paths.++## Phase 5 — Slow / Meta Update Later++Defer this until patch proposals, edit budgets, rejections, and optional evals+produce enough data.++First version should be report-only. Later, a protected `_meta` section can be+updated through a normal pending proposal, never directly by a per-session review.+Cross-project optimizer memory is explicitly out of scope until there is evidence+it helps ai-memory users.++## Completion Criteria++This roadmap is complete when phases 1–4 are implemented with docs, migrations,+tests, and changelog entries, and phase 5 has either a report-only design or a+documented deferral with evidence requirements.diff --git a/docs/auto-improvement-loop.md b/docs/auto-improvement-loop.mdindex 263fed88..c4eaf016 100644--- a/docs/auto-improvement-loop.md+++ b/docs/auto-improvement-loop.md@@ -175,13 +175,26 @@ The shipped feature is an audit-first learning reviewer:3. Produces a structured proposal containing small page creates or updates.4. Stores the proposal in a pending-review queue with evidence and diffs.5. Applies approved proposals through `Wiki::apply_batch`, admission webhooks,- auth capabilities, audit logging, and the single writer actor.+ auth capabilities, audit logging, and the single writer actor.Auto-approval is the default, but it still records staged proposals and appliesthem through the same approval path. Admins who want a human queue set`[auto_improve] require_approval = true`; admins who want no automatic review set`[auto_improve.scheduler] enabled = false`.+High-impact targets can also be guarded by an operator-supplied executable eval+gate. `[auto_improve.eval]` defaults to disabled; when enabled, proposals whose+paths match the configured prefixes (default `_rules` and `procedures`) are sent+to the configured command after LLM review validation and before staging or+auto-approval. The command receives JSON on stdin with proposal metadata plus+before/after bodies and must return JSON like+`{ "score_before": 0.72, "score_after": 0.76, "passed": true }`. Command errors,+timeouts, invalid JSON, `passed = false`, missing `passed`, or score deltas below+`min_delta` reject only that targeted proposal. Non-targeted proposals bypass the+gate. If all proposals fail eval, the run is still staged with zero proposals and+the rejected candidates so the rejection buffer can remember the failed attempt.+Hooks never run the eval command.+## Proposed Page Targets| Target | Use for | Notes |@@ -280,6 +293,17 @@ min_session_duration_secs = 120min_confidence = 0.75max_input_tokens = 24000max_proposals_per_run = 5+max_patchable_pages = 8+max_patchable_body_chars = 8000+max_edits_per_proposal = 5+max_edit_content_chars = 4000+max_changed_chars_per_proposal = 12000+max_patch_edits_per_run = 8+max_rejection_context = 50+rejection_context_days = 180+max_final_body_chars = 32000+max_rule_page_tokens = 2000+max_procedure_page_tokens = 2000include_raw_fallback = falseproposal_actor = "auto_improve"pending_path = "_pending/auto-improve"@@ -296,6 +320,12 @@ background review. `[auto_improve] require_approval` controls whether validatedproposals are applied automatically or left pending. They intentionally do notimply each other.+`max_rejection_context` and `rejection_context_days` bound the persistent+rejection-buffer summary included in future reviewer prompts. The buffer is+scoped by `workspace_id` + `project_id` and stores human rejects, approval+conflicts/failures, and validator/model rejected candidates when they carry a+reason.+## Proposal FormatThe LLM output should be structured JSON, validated before anything is staged: