Merge pull request #143 from dirge-code/phase-8-integration

Phase 8: Integration — Wire Memory, Skills, Session DB, Curator

Author: yogthos

.beads/issues.jsonl

@@ -138,6 +138,28 @@ pub async fn build_agent_inner<M: CompletionModel + 'static>(
         preamble.push_str(&format!("\nGit branch: {}", branch));
     }
 
+    // Phase 8: inject per-project memory + skills into the system
+    // prompt. Frozen snapshots of MEMORY.md and PITFALLS.md become
+    // reference material for every turn. Skills from .dirge/skills/
+    // and global dirs are listed so the model knows what procedural
+    // knowledge is available (it loads them on demand via the
+    // `skill` tool).
+    if let Ok(cwd) = std::env::current_dir() {
+        let paths = crate::extras::dirge_paths::ProjectPaths::new(&cwd);
+        if let Ok(mem) = crate::extras::memory_store::MemoryStore::load_memory(&paths) {
+            let mem_text = mem.format_for_system_prompt();
+            if !mem_text.is_empty() {
+                preamble.push_str(&mem_text);
+            }
+        }
+        if let Ok(pit) = crate::extras::memory_store::MemoryStore::load_pitfalls(&paths) {
+            let pit_text = pit.format_for_system_prompt();
+            if !pit_text.is_empty() {
+                preamble.push_str(&pit_text);
+            }
+        }
+    }
+
     // Inject mode-specific reminders
     if let Some(prompt_name) = &context.current_prompt_name {
         let plan_exists = std::env::current_dir()

src/agent/builder.rs

@@ -16,9 +16,18 @@
 //! - Frozen conversation snapshot
 //! - Fire-and-forget (daemon thread pattern)
 
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
+
 use crate::extras::dirge_paths::ProjectPaths;
 use crate::provider::AnyAgent;
 
+/// Minimum interval between background reviews (seconds).
+const MIN_REVIEW_INTERVAL_SECS: u64 = 900; // 15 minutes
+
+/// Last review timestamp (Unix seconds).
+static LAST_REVIEW: AtomicU64 = AtomicU64::new(0);
+
 /// Review prompt focused on project memory and pitfalls.
 /// Port of Hermes's `_MEMORY_REVIEW_PROMPT` adapted for coding context.
 const MEMORY_REVIEW_PROMPT: &str = r#"Review the conversation above and update project memory.
@@ -90,17 +99,29 @@ Be specific and actionable. Future sessions should benefit from what you learned
 /// This is fire-and-forget — it runs in a `tokio::spawn` task and
 /// returns immediately. Failures are logged to stderr and never
 /// block the user.
-pub fn spawn_background_review(
-    agent: AnyAgent,
-    _paths: ProjectPaths,
-    transcript: String,
-) {
+pub fn spawn_background_review(agent: AnyAgent, _paths: ProjectPaths, transcript: String) {
+    // Rate-limit: skip if a review ran recently. Uses atomic
+    // compare-and-swap so concurrent Done events from different
+    // sessions don't race — only the first one wins.
+    let now = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|d| d.as_secs())
+        .unwrap_or(0);
+    let last = LAST_REVIEW.load(Ordering::Relaxed);
+    if now.saturating_sub(last) < MIN_REVIEW_INTERVAL_SECS {
+        tracing::debug!(
+            target: "dirge::review",
+            elapsed_secs = %(now - last),
+            "Skipping background review — last review was too recent"
+        );
+        return;
+    }
+    LAST_REVIEW.store(now, Ordering::Relaxed);
+
     tokio::spawn(async move {
         // Build a review runner with only memory + skill tools.
-        let review_runner = agent.spawn_review_runner(
-            COMBINED_REVIEW_PROMPT.to_string(),
-            transcript,
-        );
+        let review_runner =
+            agent.spawn_review_runner(COMBINED_REVIEW_PROMPT.to_string(), transcript);
 
         // Drain events. We don't render them — the review runs
         // silently in the background.
@@ -134,3 +155,145 @@ pub fn spawn_background_review(
         }
     });
 }
+
+/// Build a human-readable transcript from session messages for
+/// background review. Includes user text, assistant text, tool
+/// call names+args, and tool results. Compaction summaries are
+/// included as system context.
+pub fn build_transcript(session: &crate::session::Session) -> String {
+    let mut out = String::new();
+    for msg in &session.messages {
+        match msg.role {
+            crate::session::MessageRole::User => {
+                out.push_str(&format!("User: {}\n\n", msg.content));
+            }
+            crate::session::MessageRole::Assistant => {
+                if !msg.content.is_empty() {
+                    out.push_str(&format!("Assistant: {}\n", msg.content));
+                }
+                for tc in &msg.tool_calls {
+                    let args_str =
+                        serde_json::to_string(&tc.args).unwrap_or_else(|_| "{}".to_string());
+                    out.push_str(&format!("  [Tool: {}({})]\n", tc.name, args_str));
+                    match &tc.state {
+                        crate::session::ToolCallState::Completed { result } => {
+                            let truncated = truncate_tool_result(result);
+                            out.push_str(&format!("  [Result: {}]\n", truncated));
+                        }
+                        crate::session::ToolCallState::Interrupted => {
+                            out.push_str("  [Result: <interrupted>]\n");
+                        }
+                        crate::session::ToolCallState::Failed { error } => {
+                            out.push_str(&format!("  [Result: <failed: {}>]\n", error));
+                        }
+                    }
+                }
+                if !msg.content.is_empty() || !msg.tool_calls.is_empty() {
+                    out.push('\n');
+                }
+            }
+            crate::session::MessageRole::System => {
+                out.push_str(&format!("[System: {}]\n\n", msg.content));
+            }
+        }
+    }
+    out
+}
+
+fn truncate_tool_result(result: &str) -> String {
+    const MAX_TOOL_RESULT: usize = 2000;
+    if result.len() <= MAX_TOOL_RESULT {
+        result.to_string()
+    } else {
+        let truncated: String = result.chars().take(MAX_TOOL_RESULT).collect();
+        format!("{}… (truncated, {} bytes total)", truncated, result.len())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::session::{MessageRole, Session, ToolCallEntry, ToolCallState};
+
+    fn make_session() -> Session {
+        Session::new("test-provider", "test-model", 128_000)
+    }
+
+    #[test]
+    fn transcript_includes_user_and_assistant() {
+        let mut s = make_session();
+        s.add_message(MessageRole::User, "how do I build this?");
+        s.add_message(MessageRole::Assistant, "Run cargo build");
+
+        let t = build_transcript(&s);
+        assert!(t.contains("User: how do I build this?"));
+        assert!(t.contains("Assistant: Run cargo build"));
+    }
+
+    #[test]
+    fn transcript_includes_tool_calls_and_results() {
+        let mut s = make_session();
+        s.add_message(MessageRole::User, "read the file");
+        let tc = ToolCallEntry {
+            id: "call-1".to_string(),
+            name: "read".to_string(),
+            args: serde_json::json!({"path": "/tmp/x"}),
+            state: ToolCallState::Completed {
+                result: "file contents here".to_string(),
+            },
+        };
+        s.add_message_with_tool_calls(MessageRole::Assistant, "Let me read that.", vec![tc]);
+
+        let t = build_transcript(&s);
+        assert!(t.contains("[Tool: read("));
+        assert!(t.contains("[Result: file contents here]"));
+    }
+
+    #[test]
+    fn transcript_truncates_large_tool_results() {
+        let mut s = make_session();
+        let big = "x".repeat(3000);
+        let tc = ToolCallEntry {
+            id: "c1".to_string(),
+            name: "bash".to_string(),
+            args: serde_json::json!({"cmd": "cat big.txt"}),
+            state: ToolCallState::Completed {
+                result: big.clone(),
+            },
+        };
+        s.add_message_with_tool_calls(MessageRole::Assistant, "", vec![tc]);
+
+        let t = build_transcript(&s);
+        assert!(t.contains("truncated"));
+        assert!(!t.contains(&big));
+    }
+
+    #[test]
+    fn transcript_includes_system_messages() {
+        let mut s = make_session();
+        s.add_message(
+            MessageRole::System,
+            "compaction summary: previous work on auth module",
+        );
+        s.add_message(MessageRole::User, "continue");
+
+        let t = build_transcript(&s);
+        assert!(t.contains("[System: compaction summary"));
+        assert!(t.contains("User: continue"));
+    }
+
+    #[test]
+    fn transcript_handles_interrupted_tool() {
+        let mut s = make_session();
+        let tc = ToolCallEntry {
+            id: "ci".to_string(),
+            name: "bash".to_string(),
+            args: serde_json::json!({}),
+            state: ToolCallState::Interrupted,
+        };
+        s.add_message_with_tool_calls(MessageRole::Assistant, "", vec![tc]);
+
+        let t = build_transcript(&s);
+        assert!(t.contains("<interrupted>"));
+    }
+}

src/agent/review.rs

@@ -14,18 +14,48 @@
 
 use std::path::{Path, PathBuf};
 
-/// Walk up from `cwd` until a `.git/` directory is found.
-/// Returns `cwd` unchanged if no git root is found (user may
-/// be outside a repo — per-project features degrade gracefully).
+/// Check if a path is a git reference (either a `.git` directory
+/// or a `.git` file referencing the real git dir, as used by
+/// `git worktree`).
+fn is_git_root_marker(path: &Path) -> bool {
+    let git = path.join(".git");
+    if git.is_dir() {
+        return true;
+    }
+    // Git worktrees: .git is a file containing "gitdir: <path>".
+    if git.is_file() {
+        if let Ok(content) = std::fs::read_to_string(&git) {
+            return content.starts_with("gitdir:");
+        }
+    }
+    false
+}
+
+/// Walk up from `cwd` until a `.git/` directory or worktree
+/// `.git` file is found. Returns `cwd` unchanged if no git root
+/// is found (user may be outside a repo — per-project features
+/// degrade gracefully).
 pub fn find_git_root(cwd: &Path) -> PathBuf {
-    let mut current = cwd.to_path_buf();
+    // Canonicalize to resolve symlinks in the path chain.
+    let cwd = if let Ok(canon) = cwd.canonicalize() {
+        canon
+    } else {
+        cwd.to_path_buf()
+    };
+
+    let mut current = cwd.clone();
     loop {
-        if current.join(".git").is_dir() {
+        if is_git_root_marker(&current) {
             return current;
         }
-        if !current.pop() {
-            return cwd.to_path_buf();
+        let parent = match current.parent() {
+            Some(p) => p.to_path_buf(),
+            None => return cwd.clone(),
+        };
+        if parent == current {
+            return cwd.clone();
         }
+        current = parent;
     }
 }
 
@@ -117,12 +147,14 @@ mod tests {
         );
     }
 
-    /// `/tmp` has no `.git/` — should return `/tmp` unchanged.
+    /// `/tmp` has no `.git/` — should return `/tmp` unchanged
+    /// (canonicalized if possible).
     #[test]
     fn find_git_root_falls_back_to_cwd_outside_repo() {
         let tmp = std::env::temp_dir();
+        let expected = tmp.canonicalize().unwrap_or_else(|_| tmp.clone());
         let root = find_git_root(&tmp);
-        assert_eq!(root, tmp);
+        assert_eq!(root, expected);
     }
 
     /// `DIRGE_PROJECT_ROOT` wins over auto-detection.
@@ -181,4 +213,43 @@ mod tests {
         assert_eq!(f.file_name().unwrap(), "MEMORY.md");
         assert!(f.starts_with(paths.memory_dir()));
     }
+
+    /// Git worktrees use a `.git` file (not directory) containing
+    /// `gitdir: <path>`. find_git_root should recognise this as a
+    /// git root marker and stop walking.
+    #[test]
+    fn find_git_root_recognises_worktree_marker() {
+        let dir = std::env::temp_dir().join(format!("dirge-worktree-test-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&dir);
+        std::fs::create_dir_all(&dir).unwrap();
+        // Create a worktree-style .git file.
+        std::fs::write(
+            dir.join(".git"),
+            "gitdir: /some/real/path/.git/worktrees/foo\n",
+        )
+        .unwrap();
+
+        let root = find_git_root(&dir);
+        let expected = dir.canonicalize().unwrap_or_else(|_| dir.clone());
+        assert_eq!(root, expected, "should stop at worktree .git file");
+
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
+    /// Paths with symlinks should still find the correct git root.
+    #[test]
+    fn find_git_root_with_symlinks() {
+        let cwd = std::env::current_dir().unwrap();
+        let root = find_git_root(&cwd);
+        assert!(
+            root.join(".git").is_dir() || {
+                let git_file = root.join(".git");
+                git_file.is_file()
+                    && std::fs::read_to_string(&git_file)
+                        .map(|c| c.starts_with("gitdir:"))
+                        .unwrap_or(false)
+            },
+            "expected {root:?} to be a git root"
+        );
+    }
 }