feat: add persistent auto-memory system (#3241)

feat: add persistent auto-memory system

Implement a file-based persistent memory system that allows the AI to retain knowledge about users, feedback, projects, and references across sessions.

## Implementation Details
- MemoryStore data layer with FNV-1a workspace fingerprinting
- MemoryRead/MemoryWrite tools with security hardening (path traversal, symlink, absolute path, and size limit protections)
- System prompt injection of MEMORY.md index with prompt injection mitigation (fenced code block + trust-lowering notice)
- autoMemoryEnabled config option (defaults to true)
- Doctor health check for auto-memory state
- /memory command enhancement showing persistent memory info

## Verification
✓ 1023 lib tests pass
✓ Output format contract tests pass
✓ Release build succeeds
✓ Security hardening verified

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
Ming LiuandClaude Opus 4.6 authored and GitHub committed 2026-10-13 07:13:36 +09:00
1 parent d6b7109d33
commit 43d68dba75
9 files changed
+881 -11

No files matched your search

+131 -1
View File
@@ -28,7 +28,7 @@ use runtime::{
write_file_in_workspace, ApiClient, ApiRequest, AssistantEvent, BashCommandInput,
BashCommandOutput, BranchFreshness, ConfigLoader, ContentBlock, ConversationMessage,
ConversationRuntime, GrepSearchInput, LaneCommitProvenance, LaneEvent, LaneEventBlocker,
LaneEventName, LaneEventStatus, LaneFailureClass, McpDegradedReport, MessageRole,
LaneEventName, LaneEventStatus, LaneFailureClass, McpDegradedReport, MemoryStore, MessageRole,
PermissionMode, PermissionPolicy, PromptCacheEvent, ProviderFallbackConfig, RuntimeError,
Session, TaskPacket, ToolError, ToolExecutor,
};
@@ -1167,6 +1167,33 @@ pub fn mvp_tool_specs() -> Vec<ToolSpec> {
}),
required_permission: PermissionMode::ReadOnly,
},
ToolSpec {
name: "MemoryRead",
description: "Read a file from the persistent memory store. The memory store lives outside the workspace (under ~/.claw/projects/<workspace-hash>/memory/) and is not subject to the workspace boundary. Use this to read memory entries or the MEMORY.md index.",
input_schema: json!({
"type": "object",
"properties": {
"file_path": { "type": "string", "description": "Relative path within the memory directory (e.g. 'MEMORY.md' or 'user_role.md')." }
},
"required": ["file_path"],
"additionalProperties": false
}),
required_permission: PermissionMode::ReadOnly,
},
ToolSpec {
name: "MemoryWrite",
description: "Write a file to the persistent memory store. The memory store lives outside the workspace (under ~/.claw/projects/<workspace-hash>/memory/) and is not subject to the workspace boundary. Use this to create or update memory entries and the MEMORY.md index. Parent directories are created automatically.",
input_schema: json!({
"type": "object",
"properties": {
"file_path": { "type": "string", "description": "Relative path within the memory directory (e.g. 'MEMORY.md' or 'feedback_style.md')." },
"content": { "type": "string", "description": "Full file content to write." }
},
"required": ["file_path", "content"],
"additionalProperties": false
}),
required_permission: PermissionMode::WorkspaceWrite,
},
ToolSpec {
name: "LSP",
description: "Query Language Server Protocol for code intelligence (symbols, references, diagnostics).",
@@ -1479,6 +1506,8 @@ fn execute_tool_with_enforcer(
"CronCreate" => from_value::<CronCreateInput>(input).and_then(run_cron_create),
"CronDelete" => from_value::<CronDeleteInput>(input).and_then(run_cron_delete),
"CronList" => run_cron_list(input.clone()),
"MemoryRead" => from_value::<MemoryReadInput>(input).and_then(run_memory_read),
"MemoryWrite" => from_value::<MemoryWriteInput>(input).and_then(run_memory_write),
"LSP" => from_value::<LspInput>(input).and_then(run_lsp),
"ListMcpResources" => {
from_value::<McpResourceInput>(input).and_then(run_list_mcp_resources)
@@ -1848,6 +1877,96 @@ fn run_cron_list(_input: Value) -> Result<String, String> {
}))
}
const MEMORY_MAX_FILE_BYTES: u64 = 10 * 1024 * 1024;
#[allow(clippy::needless_pass_by_value)]
fn run_memory_read(input: MemoryReadInput) -> Result<String, String> {
let store = memory_store_for_cwd()?;
let target = resolve_memory_path(&store, &input.file_path)?;
reject_symlink(&target)?;
let meta = std::fs::metadata(&target).map_err(|e| {
if e.kind() == std::io::ErrorKind::NotFound {
format!("memory file not found: {}", target.display())
} else {
format!("failed to read memory file: {e}")
}
})?;
if meta.len() > MEMORY_MAX_FILE_BYTES {
return Err(format!(
"memory file too large ({} bytes, max {MEMORY_MAX_FILE_BYTES})",
meta.len(),
));
}
let content =
std::fs::read_to_string(&target).map_err(|e| format!("failed to read memory file: {e}"))?;
to_pretty_json(json!({
"file_path": target.display().to_string(),
"content": content
}))
}
#[allow(clippy::needless_pass_by_value)]
fn run_memory_write(input: MemoryWriteInput) -> Result<String, String> {
if input.content.len() as u64 > MEMORY_MAX_FILE_BYTES {
return Err(format!(
"content too large ({} bytes, max {MEMORY_MAX_FILE_BYTES})",
input.content.len(),
));
}
let store = memory_store_for_cwd()?;
let target = resolve_memory_path(&store, &input.file_path)?;
store
.ensure_dir()
.map_err(|e| format!("failed to create memory directory: {e}"))?;
if let Some(parent) = target.parent() {
std::fs::create_dir_all(parent)
.map_err(|e| format!("failed to create parent directory: {e}"))?;
}
if target.exists() {
reject_symlink(&target)?;
}
let kind = if target.exists() { "update" } else { "create" };
std::fs::write(&target, &input.content)
.map_err(|e| format!("failed to write memory file: {e}"))?;
to_pretty_json(json!({
"type": kind,
"file_path": target.display().to_string(),
"memory_dir": store.memory_dir().display().to_string()
}))
}
fn reject_symlink(path: &Path) -> Result<(), String> {
match std::fs::symlink_metadata(path) {
Ok(meta) if meta.file_type().is_symlink() => {
Err(format!("refusing to follow symlink: {}", path.display()))
}
_ => Ok(()),
}
}
fn memory_store_for_cwd() -> Result<MemoryStore, String> {
let cwd = std::env::current_dir().map_err(|e| e.to_string())?;
Ok(MemoryStore::for_workspace(&cwd))
}
fn resolve_memory_path(store: &MemoryStore, relative: &str) -> Result<PathBuf, String> {
let relative = relative.trim();
if relative.is_empty() {
return Err("file_path must not be empty".to_string());
}
let path = Path::new(relative);
if path.is_absolute() {
return Err("file_path must be relative to the memory directory, not absolute".to_string());
}
if path
.components()
.any(|c| c == std::path::Component::ParentDir)
{
return Err("file_path must not contain '..' components".to_string());
}
Ok(store.memory_dir().join(path))
}
#[allow(clippy::needless_pass_by_value)]
fn run_lsp(input: LspInput) -> Result<String, String> {
let registry = global_lsp_registry();
@@ -3016,6 +3135,17 @@ struct CronDeleteInput {
cron_id: String,
}
#[derive(Debug, Deserialize)]
struct MemoryReadInput {
file_path: String,
}
#[derive(Debug, Deserialize)]
struct MemoryWriteInput {
file_path: String,
content: String,
}
#[derive(Debug, Deserialize)]
struct LspInput {
action: String,