Merge pull request gi-dellav#185 from xavierforge/feat/memory-edit-dedupe

feat(memory): add memory_edit, backups, and long-term append dedup

Author: gi-dellav

docs/MEMORY.md

@@ -51,7 +51,7 @@ Enum selecting which file to write to:
 
 ### `WriteMode`
 
-- `Append` — append content, inserting a `\n` separator if the file does not end with one
+- `Append` — append content, inserting a `\n` separator if the file does not end with one. For `long_term` only, appended lines are deduplicated (see [Long-term append deduplication](#long-term-append-deduplication))
 - `Overwrite` — replace the entire file
 
 ### `Mem`
@@ -120,7 +120,7 @@ Rules:
 
 ## Rig Tools
 
-Three tools are registered when the `memory` feature is enabled:
+Four tools are registered when the `memory` feature is enabled:
 
 ### `memory_write`
 
@@ -140,6 +140,38 @@ Three tools are registered when the `memory` feature is enabled:
 
 `source=list` enumerates all `.md` files in the store (global MEMORY.md + current project's notes + daily logs).
 
+### `memory_edit`
+
+| Parameter | Type | Description |
+|---|---|---|
+| `target` | string | `long_term`, `scratchpad`, `daily`, or `note` |
+| `name` | string (opt) | Note stem (required for `note`); or a `YYYY-MM-DD` date for `daily` to edit an earlier day (defaults to today) |
+| `old_str` | string (opt) | Substring to replace; must occur exactly once. Omit to delete a whole note |
+| `new_str` | string | Replacement text; empty string deletes the matched substring |
+
+Replaces a unique substring in a memory file in place. `old_str` is matched literally (no fuzzy matching) and must occur exactly once in the target file; zero or multiple matches fail without writing. `new_str` replaces the match verbatim with no newline cleanup, so an empty `new_str` deletes exactly the matched text, and including the trailing newline in `old_str` deletes a whole line.
+
+Omitting `old_str` deletes an entire note file (`notes/<name>.md`) from disk; this requires `target=note` with a `name`. Omitting `old_str` for `long_term`, `scratchpad`, or `daily` is rejected and changes nothing. Deleting a note that does not exist is an error.
+
+---
+
+## Backups
+
+Content-destroying mutations first copy the current file to a sibling `.bak` (single version, `MEMORY.md` becomes `MEMORY.bak`), so the pre-mutation content stays recoverable. There is exactly one `.bak` per file: each qualifying mutation overwrites the previous `.bak` rather than keeping a history. The `.bak` extension keeps these files out of `memory_read source=list` and `memory_search`, which both filter to `.md` only, so backups never leak into the model's context.
+
+A backup is taken only before these operations (and only when the target file already exists: a first-ever overwrite of a not-yet-created file has nothing to back up and skips silently):
+
+| Operation | `long_term` | `scratchpad` | `daily` | `note` |
+|---|---|---|---|---|
+| `memory_write` overwrite | Backs up | Backs up | No | No |
+| `memory_edit` content-replace (`old_str` given) | Backs up | Backs up | No | No |
+| `memory_edit` whole-note deletion (`old_str` omitted) | n/a | n/a | n/a | Backs up |
+| any append | No | No | No | No |
+
+Appends are non-destructive by construction, so they never back up. `daily` and `note` content edits are targeted unique-match replacements (low-risk and already reversible via a re-edit), so they are deliberately left un-backed-up to avoid churn.
+
+If the backup copy itself fails (for example the `.bak` path is not writable), the mutation still proceeds (the primary operation is what was asked for), but the tool response is suffixed with a `warning: backup failed, no .bak written` note so the caller knows there is no undo for that change. The failure is also logged.
+
 ### `memory_search`
 
 | Parameter | Type | Description |
@@ -148,6 +180,26 @@ Three tools are registered when the `memory` feature is enabled:
 
 ---
 
+## Long-term append deduplication
+
+`MEMORY.md` is curated one fact per line, so `memory_write target=long_term mode=append` deduplicates its lines. This applies to `long_term` appends **only**: `scratchpad`, `daily`, and `note` appends are never deduplicated (repeats are preserved), and no target dedups on `overwrite`.
+
+Comparison is whitespace-insensitive: each line is normalized by trimming and collapsing every run of Unicode whitespace (ASCII spaces/tabs and the full-width `U+3000` space) to a single ASCII space, preserving case. Two lines that differ only in whitespace width are duplicates.
+
+For a `long_term` append batch (the incoming content split on `\n`):
+
+1. Batch-internal duplicates are dropped, keeping the first occurrence.
+2. Lines whose normalized form already exists anywhere in `MEMORY.md` are dropped.
+3. Blank / whitespace-only lines normalize to empty; they are never a dedup key (they carry no fact) and are kept verbatim.
+4. If nothing meaningful survives, the write is skipped entirely and the file is left byte-for-byte unchanged.
+
+The response message reflects the outcome:
+- No duplicates: `Wrote N bytes to <path>` (unchanged).
+- Partial dedup: `Wrote N bytes to <path> (skipped M duplicate line(s))`.
+- Whole batch dropped: `Nothing written to <path>: all M line(s) were duplicates`.
+
+---
+
 ## Search Algorithm
 
 `Mem::search(query)` implements a case-insensitive, multi-term keyword search:

src/agent/builder.rs

@@ -235,11 +235,15 @@ pub async fn build_agent_inner<M: CompletionModel + 'static>(
 
         #[cfg(feature = "memory")]
         {
-            use crate::extras::memory::{MemoryRead, MemorySearch, MemoryWrite};
+            use crate::extras::memory::{MemoryEdit, MemoryRead, MemorySearch, MemoryWrite};
             all_tools.push(Box::new(MemoryWrite::new(
                 permission.clone(),
                 ask_tx.clone(),
             )));
+            all_tools.push(Box::new(MemoryEdit::new(
+                permission.clone(),
+                ask_tx.clone(),
+            )));
             all_tools.push(Box::new(MemoryRead::new(
                 permission.clone(),
                 ask_tx.clone(),

src/agent/prompt.rs

@@ -71,14 +71,23 @@ is already injected above; use the tools to read more or to persist new memory.
 
 - memory_write target=long_term: durable facts, preferences, and decisions that \
 should ALWAYS be remembered (written to MEMORY.md, injected every session). Keep \
-it curated and concise.
+it curated and concise: write ONE fact per line. Appends are deduplicated \
+(whitespace-insensitive), so re-appending a line already present is skipped and \
+leaves the file unchanged.
 - memory_write target=daily: a running log of what happened today. Use for \
 progress, findings, and context worth recalling soon but not forever.
 - memory_write target=scratchpad: a checklist; write `- [ ]` items. Open items \
 are injected automatically; mark `- [x]` or rewrite with mode=overwrite when done.
 - memory_write target=note name=<stem>: longer reference material kept on disk \
 and NOT auto-injected. Find it later with memory_search, then read it in full \
 with memory_read source=note name=<stem>.
+- memory_edit: replace a unique substring in a memory file in place (target=\
+long_term, scratchpad, daily, or note). old_str must occur EXACTLY once, matched \
+literally, so include enough surrounding text to make it unique; a zero- or \
+multiple-match old_str fails without writing. Set new_str to an empty string to \
+delete the matched text, and include the trailing newline in old_str to delete a \
+whole line. Use this to fix or remove existing memory; use memory_write to append \
+or overwrite.
 - memory_search: keyword search over all memory (including older daily logs not \
 injected above). Space-separated words are separate terms. It locates relevant \
 files with a little context — to use a file's full content, follow up with \