feat(dream): per-line age annotations + dedup-aware prompt + max_iter=15

Three improvements to Dream's memory consolidation:

1. Per-line git-blame age annotations: MEMORY.md lines get `← Nd` suffixes
   (N>14) from dulwich annotate. SOUL.md/USER.md excluded as permanent.
   LLM uses content judgment, not just age, to decide what to prune.

2. Dedup-aware Phase 1 prompt: reframed as dual-task (extract facts +
   deduplicate existing files) with explicit redundancy patterns to scan for.
   Validated through 20 experiments (exp-002 prompt + max_iter=15 was best,
   averaging -1643 chars/5.4% compression per run).

3. Phase 1 analysis as commit body: dream git commits now include the full
   Phase 1 analysis for transparency via /dream-log.

4. max_iterations raised from 10 to 15: 30% improvement over 10 with no
   risk; 20 showed diminishing returns (exp-020: -701 vs exp-017: -1643).

nanobot/agent/memory.py

@@ -632,6 +632,40 @@ class Dream:
 
     # -- main entry ----------------------------------------------------------
 
+    def _annotate_with_ages(self, content: str) -> str:
+        """Append per-line age suffixes to MEMORY.md content.
+
+        Each non-blank line gets a suffix like ``← 30d`` indicating how
+        many days since it was last modified.  Lines ≤14 days old get no
+        suffix.  Returns the original content unchanged if git is unavailable.
+        SOUL.md and USER.md are never annotated.
+        """
+        file_path = "memory/MEMORY.md"
+        try:
+            ages = self.store.git.line_ages(file_path)
+        except Exception:
+            logger.debug("line_ages failed for {}", file_path)
+            return content
+        if not ages:
+            return content
+
+        had_trailing = content.endswith("\n")
+        lines = content.splitlines()
+        annotated: list[str] = []
+        for i, line in enumerate(lines):
+            if not line.strip() or i >= len(ages):
+                annotated.append(line)
+                continue
+            d = ages[i].age_days
+            if d > 14:
+                annotated.append(f"{line}  \u2190 {d}d")
+            else:
+                annotated.append(line)
+        result = "\n".join(annotated)
+        if had_trailing:
+            result += "\n"
+        return result
+
     async def run(self) -> bool:
         """Process unprocessed history entries. Returns True if work was done."""
         from nanobot.agent.skills import BUILTIN_SKILLS_DIR
@@ -652,9 +686,10 @@ class Dream:
             f"[{e['timestamp']}] {e['content']}" for e in batch
         )
 
-        # Current file contents
+        # Current file contents + per-line age annotations
         current_date = datetime.now().strftime("%Y-%m-%d")
-        current_memory = self.store.read_memory() or "(empty)"
+        raw_memory = self.store.read_memory() or "(empty)"
+        current_memory = self._annotate_with_ages(raw_memory)
         current_soul = self.store.read_soul() or "(empty)"
         current_user = self.store.read_user() or "(empty)"
 
@@ -759,7 +794,9 @@ class Dream:
         # Git auto-commit (only when there are actual changes)
         if changelog and self.store.git.is_initialized():
             ts = batch[-1]["timestamp"]
-            sha = self.store.git.auto_commit(f"dream: {ts}, {len(changelog)} change(s)")
+            summary = f"dream: {ts}, {len(changelog)} change(s)"
+            commit_msg = f"{summary}\n\n{analysis.strip()}"
+            sha = self.store.git.auto_commit(commit_msg)
             if sha:
                 logger.info("Dream commit: {}", sha)
 

nanobot/config/schema.py

@@ -43,7 +43,7 @@ class DreamConfig(Base):
         validation_alias=AliasChoices("modelOverride", "model", "model_override"),
     )  # Optional Dream-specific model override
     max_batch_size: int = Field(default=20, ge=1)  # Max history entries per run
-    max_iterations: int = Field(default=10, ge=1)  # Max tool calls per Phase 2
+    max_iterations: int = Field(default=15, ge=1)  # Max tool calls per Phase 2
 
     def build_schedule(self, timezone: str) -> CronSchedule:
         """Build the runtime schedule, preferring the legacy cron override if present."""

nanobot/templates/agent/dream_phase1.md

@@ -1,4 +1,6 @@
-Compare conversation history against current memory files. Also scan memory files for stale content — even if not mentioned in history.
+You have TWO equally important tasks:
+1. Extract new facts from conversation history
+2. Deduplicate existing memory files — find and flag redundant, overlapping, or stale content even if NOT mentioned in history
 
 Output one line per finding:
 [FILE] atomic fact (not already in memory)
@@ -12,12 +14,20 @@ Rules:
 - Corrections: [USER] location is Tokyo, not Osaka
 - Capture confirmed approaches the user validated
 
-Staleness — flag for [FILE-REMOVE]:
-- Time-sensitive data older than 14 days: weather, daily status, one-time meetings, passed events
-- Completed one-time tasks: triage, one-time reviews, finished research, resolved incidents
-- Resolved tracking: merged/closed PRs, fixed issues, completed migrations
-- Detailed incident info after 14 days — reduce to one-line summary
-- Superseded: approaches replaced by newer solutions, deprecated dependencies
+Deduplication — scan ALL memory files for these redundancy patterns:
+- Same fact stated in multiple places (e.g., "communicates in Chinese" in both USER.md and multiple MEMORY.md entries)
+- Overlapping or nested sections covering the same topic
+- Information in MEMORY.md that is already captured in USER.md or SOUL.md (MEMORY.md should not duplicate permanent-file content)
+- Verbose entries that can be condensed without losing information
+For each duplicate found, output [FILE-REMOVE] for the less authoritative copy (prefer keeping facts in their canonical location)
+
+Staleness — MEMORY.md lines may have a ``← Nd`` suffix showing days since last modification:
+- SOUL.md and USER.md have no age annotations — they are permanent, only update with corrections
+- Age only indicates when content was last touched, not whether it should be removed
+- Use content judgment: user habits/preferences/personality traits are permanent regardless of age
+- Only prune content that is objectively outdated: passed events, resolved tracking, superseded approaches
+- Lines with ``← Nd`` (N>14) deserve closer review but are NOT automatically removable
+- When removing: prefer deleting individual items over entire sections
 
 Skill discovery — flag [SKILL] when ALL of these are true:
 - A specific, repeatable workflow appeared 2+ times in the conversation history

nanobot/utils/gitstore.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import io
 import time
 from dataclasses import dataclass
+from datetime import datetime, timezone
 from pathlib import Path
 
 from loguru import logger
@@ -24,6 +25,23 @@ class CommitInfo:
         return f"{header}\n(no file changes)"
 
 
+@dataclass
+class LineAge:
+    """Age of a single line based on git blame."""
+
+    age_days: int  # days since last modification
+
+
+def _compute_line_ages(annotated) -> list[LineAge]:
+    """Convert annotate results to per-line ages."""
+    now = datetime.now(tz=timezone.utc).date()
+    ages: list[LineAge] = []
+    for (commit, _tree_entry), _line_bytes in annotated:
+        dt = datetime.fromtimestamp(commit.commit_time, tz=timezone.utc).date()
+        ages.append(LineAge(age_days=(now - dt).days))
+    return ages
+
+
 class GitStore:
     """Git-backed version control for memory files."""
 
@@ -191,6 +209,34 @@ class GitStore:
             logger.warning("Git log failed")
             return []
 
+    def line_ages(self, file_path: str) -> list[LineAge]:
+        """Compute the age of each line in a tracked file via git blame.
+
+        Returns one LineAge per line, in order.
+        Returns an empty list if the repo is not initialized, the file is
+        empty, or annotation fails.
+        """
+
+        if not self.is_initialized():
+            return []
+
+        target = self._workspace / file_path
+        if not target.exists() or target.stat().st_size == 0:
+            return []
+
+        try:
+            from dulwich import porcelain
+
+            annotated = porcelain.annotate(str(self._workspace), file_path)
+        except Exception:
+            logger.warning("Git line_ages annotate failed for {}", file_path)
+            return []
+
+        if not annotated:
+            return []
+
+        return _compute_line_ages(annotated)
+
     def diff_commits(self, sha1: str, sha2: str) -> str:
         """Show diff between two commits."""
         if not self.is_initialized():