Skip to content

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.md
index 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
### Fixed
diff --git a/Cargo.lock b/Cargo.lock
index 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.rs
index 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.rs
index 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.rs
index 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.9
max_input_tokens = 12000
max_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 = 1500
include_raw_fallback = true
proposal_actor = "review_bot"
pending_path = "_pending/review-bot"
@@ -945,6 +1044,13 @@ mod tests {
interval_secs = 1800
max_sessions_per_tick = 4
min_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.toml
index 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 = false
proposal_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 = true
interval_secs = 3600
diff --git a/crates/ai-memory-consolidate/Cargo.toml b/crates/ai-memory-consolidate/Cargo.toml
index 12c65e87..dccb2259 100644
--- a/crates/ai-memory-consolidate/Cargo.toml
+++ b/crates/ai-memory-consolidate/Cargo.toml
@@ -19,6 +19,7 @@ thiserror.workspace = true
serde.workspace = true
serde_json.workspace = true
schemars.workspace = true
+sha2.workspace = true
tokio.workspace = true
tracing.workspace = true
jiff.workspace = true
diff --git a/crates/ai-memory-consolidate/src/auto_improve.rs b/crates/ai-memory-consolidate/src/auto_improve.rs
index 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(&current);
+ if duplicate_heading_count(&sections, &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(&section.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(&section.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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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 only
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_move.rs b/crates/ai-memory-mcp/tests/admin_move.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.sql
new file mode 100644
index 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.sql
new file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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) -> WikiResult
detail.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.md
index 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 of
starting another copy. Scheduling and approval are separate. Admins can set
`[auto_improve.scheduler] enabled = false` to stop background review, or
`[auto_improve] require_approval = true` to leave scheduled and manual 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 same
pipeline 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 an
embedder is configured, vector cosine over `page_embeddings` joins
the same RRF. If compiled wiki pages miss entirely, bounded raw
@@ -335,6 +341,17 @@ min_session_duration_secs = 120
min_confidence = 0.75
max_input_tokens = 24000
max_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 = 2000
include_raw_fallback = false
proposal_actor = "auto_improve"
pending_path = "_pending/auto-improve"
diff --git a/docs/auto-improve-skillopt-roadmap.md b/docs/auto-improve-skillopt-roadmap.md
new file mode 100644
index 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.md
index 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 applies
them 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 = 120
min_confidence = 0.75
max_input_tokens = 24000
max_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 = 2000
include_raw_fallback = false
proposal_actor = "auto_improve"
pending_path = "_pending/auto-improve"
@@ -296,6 +320,12 @@ background review. `[auto_improve] require_approval` controls whether validated
proposals are applied automatically or left pending. They intentionally do not
imply 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 Format
The LLM output should be structured JSON, validated before anything is staged: