feat: wire all new packages into main flow + 5 new tests

All packages now integrated into engine.Remember():
- Step 3: Dedup rolling window (skip near-duplicates within 5min)
- Step 8: Temporal backbone (auto-link every node to previous)
- Step 9: Conflict resolver (detect contradictions, auto-supersede)

New engine methods:
- Compact(project) → merge low-confidence memories
- MentalModel(project) → auto-generated project summary

New REST endpoints:
- POST /yaad/compact
- GET /yaad/mental-model

5 new tests (22 total):
- TestConflictResolver: contradicting conventions → supersedes edge
- TestTemporalBackbone: 3 nodes → learned_in chain verified
- TestDedupRollingWindow: same content twice → same node returned
- TestCompaction: 5 low-confidence nodes → archived
- TestMentalModel: conventions+decisions+tasks → summary generated

Verified twice:
- First: build + vet + 22/22 tests pass
- Second: clean build + 3/3 consecutive runs pass

Author: Patel230

integration_test.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
+	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"os"
@@ -552,6 +553,138 @@ func TestGitSync(t *testing.T) {
 	}
 }
 
+func TestConflictResolver(t *testing.T) {
+	eng, cleanup := setup(t)
+	defer cleanup()
+
+	// Store original convention
+	old, _ := eng.Remember(engine.RememberInput{
+		Type: "convention", Content: "Use jsonwebtoken library for JWT", Scope: "project",
+	})
+
+	// Store contradicting convention (should supersede)
+	newNode, _ := eng.Remember(engine.RememberInput{
+		Type: "convention", Content: "Use jose instead of jsonwebtoken for Edge compatibility", Scope: "project",
+	})
+
+	// Verify old node confidence was lowered
+	oldUpdated, _ := eng.Store().GetNode(old.ID)
+	if oldUpdated.Confidence >= 1.0 {
+		t.Errorf("conflict: old node confidence should be lowered, got %.2f", oldUpdated.Confidence)
+	}
+
+	// Verify supersedes edge exists
+	edges, _ := eng.Store().GetEdgesFrom(newNode.ID)
+	hasSupersedes := false
+	for _, e := range edges {
+		if e.Type == "supersedes" && e.ToID == old.ID {
+			hasSupersedes = true
+		}
+	}
+	if !hasSupersedes {
+		t.Error("conflict: supersedes edge not created")
+	}
+}
+
+func TestTemporalBackbone(t *testing.T) {
+	eng, cleanup := setup(t)
+	defer cleanup()
+
+	n1, _ := eng.Remember(engine.RememberInput{Type: "convention", Content: "First convention", Scope: "project", Project: "test"})
+	n2, _ := eng.Remember(engine.RememberInput{Type: "decision", Content: "Second decision", Scope: "project", Project: "test"})
+	n3, _ := eng.Remember(engine.RememberInput{Type: "bug", Content: "Third bug report", Scope: "project", Project: "test"})
+
+	// Verify temporal chain: n1 → n2 → n3
+	edges1, _ := eng.Store().GetEdgesFrom(n1.ID)
+	hasLink12 := false
+	for _, e := range edges1 {
+		if e.Type == "learned_in" && e.ToID == n2.ID {
+			hasLink12 = true
+		}
+	}
+	edges2, _ := eng.Store().GetEdgesFrom(n2.ID)
+	hasLink23 := false
+	for _, e := range edges2 {
+		if e.Type == "learned_in" && e.ToID == n3.ID {
+			hasLink23 = true
+		}
+	}
+	if !hasLink12 {
+		t.Error("temporal: n1→n2 learned_in edge missing")
+	}
+	if !hasLink23 {
+		t.Error("temporal: n2→n3 learned_in edge missing")
+	}
+}
+
+func TestDedupRollingWindow(t *testing.T) {
+	eng, cleanup := setup(t)
+	defer cleanup()
+
+	n1, _ := eng.Remember(engine.RememberInput{
+		Type: "convention", Content: "Use jose for JWT auth", Scope: "project",
+	})
+	// Same content again — should return same node (dedup)
+	n2, _ := eng.Remember(engine.RememberInput{
+		Type: "convention", Content: "Use jose for JWT auth", Scope: "project",
+	})
+
+	if n1.ID != n2.ID {
+		t.Errorf("dedup: expected same node ID, got %s and %s", n1.ID[:8], n2.ID[:8])
+	}
+}
+
+func TestCompaction(t *testing.T) {
+	eng, cleanup := setup(t)
+	defer cleanup()
+
+	// Store 5 low-confidence nodes
+	for i := 0; i < 5; i++ {
+		n, _ := eng.Remember(engine.RememberInput{
+			Type: "decision", Content: fmt.Sprintf("Old decision %d about something", i), Scope: "project",
+		})
+		node, _ := eng.Store().GetNode(n.ID)
+		node.Confidence = 0.2
+		node.AccessCount = 0
+		eng.Store().UpdateNode(node)
+	}
+
+	// Run compaction
+	compacted, err := eng.Compact("")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if compacted == 0 {
+		t.Error("compaction: expected nodes to be compacted")
+	}
+	t.Logf("Compacted %d nodes", compacted)
+}
+
+func TestMentalModel(t *testing.T) {
+	eng, cleanup := setup(t)
+	defer cleanup()
+
+	eng.Remember(engine.RememberInput{Type: "convention", Content: "Use jose for JWT", Scope: "project"})
+	eng.Remember(engine.RememberInput{Type: "decision", Content: "Chose NATS for events", Scope: "project"})
+	eng.Remember(engine.RememberInput{Type: "task", Content: "Add rate limiting", Scope: "project"})
+
+	model, err := eng.MentalModel("")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if model.Summary == "" {
+		t.Error("mental model: empty summary")
+	}
+	if len(model.Conventions) == 0 {
+		t.Error("mental model: no conventions")
+	}
+	formatted := model.Format()
+	if formatted == "" {
+		t.Error("mental model: empty formatted output")
+	}
+	t.Logf("Mental model:\n%s", formatted)
+}
+
 func TestPhase6IntentClassifier(t *testing.T) {
 	cases := []struct {
 		query    string

internal/conflict/resolver.go

@@ -66,15 +66,15 @@ func isContradiction(newNode, oldNode *storage.Node) bool {
 	newEntities := extractKeyTerms(newNode.Content)
 	oldEntities := extractKeyTerms(oldNode.Content)
 
-	// Must share at least 2 key terms (same topic)
+	// Must share at least 1 key term for same-type nodes (same topic)
 	shared := 0
 	for term := range newEntities {
 		if oldEntities[term] {
 			shared++
 		}
 	}
-	if shared < 2 {
-		return false // different topics, not a contradiction
+	if shared < 1 {
+		return false // completely different topics
 	}
 
 	// Check for negation patterns

internal/engine/memory.go

@@ -6,21 +6,35 @@ import (
 	"time"
 
 	"github.com/google/uuid"
+	"github.com/GrayCodeAI/yaad/internal/compact"
+	"github.com/GrayCodeAI/yaad/internal/conflict"
+	"github.com/GrayCodeAI/yaad/internal/dedup"
 	"github.com/GrayCodeAI/yaad/internal/graph"
 	"github.com/GrayCodeAI/yaad/internal/intent"
+	"github.com/GrayCodeAI/yaad/internal/mental"
 	"github.com/GrayCodeAI/yaad/internal/privacy"
 	"github.com/GrayCodeAI/yaad/internal/storage"
+	"github.com/GrayCodeAI/yaad/internal/temporal"
 )
 
 // Engine is the core memory engine wrapping graph + storage.
 type Engine struct {
-	store *storage.Store
-	graph *graph.Graph
+	store    *storage.Store
+	graph    *graph.Graph
+	dedup    *dedup.Window
+	temporal *temporal.Backbone
+	conflict *conflict.Resolver
 }
 
 // New creates a memory engine.
 func New(store *storage.Store) *Engine {
-	return &Engine{store: store, graph: graph.New(store)}
+	return &Engine{
+		store:    store,
+		graph:    graph.New(store),
+		dedup:    dedup.New(5 * time.Minute),
+		temporal: temporal.New(store),
+		conflict: conflict.New(store),
+	}
 }
 
 // Graph returns the underlying graph engine.
@@ -64,7 +78,17 @@ func (e *Engine) Remember(in RememberInput) (*storage.Node, error) {
 		in.Tier = defaultTier(in.Type)
 	}
 
-	// 3. Content hash for dedup
+	// 3. Rolling window dedup (skip near-duplicates within 5min)
+	if e.dedup.IsDuplicate(content) {
+		// Find existing by hash and boost
+		hash := contentHash(content, in.Scope, in.Project)
+		existing, _ := e.store.SearchNodeByHash(hash, in.Scope, in.Project)
+		if existing != nil {
+			return existing, nil
+		}
+	}
+
+	// 4. Content hash for exact dedup
 	hash := contentHash(content, in.Scope, in.Project)
 
 	// 4. Check dedup — if exists, boost confidence
@@ -123,6 +147,12 @@ func (e *Engine) Remember(in RememberInput) (*storage.Node, error) {
 		})
 	}
 
+	// 8. Temporal backbone — auto-link to previous node in timeline
+	_ = e.temporal.Link(node.ID, in.Project)
+
+	// 9. Conflict resolution — detect and supersede contradictions
+	_, _ = e.conflict.CheckAndResolve(node)
+
 	return node, nil
 }
 
@@ -273,6 +303,17 @@ type Status struct {
 	Sessions int
 }
 
+// Compact merges low-confidence memories to keep the graph lean.
+func (e *Engine) Compact(project string) (int, error) {
+	c := compact.New(e.store, 50000)
+	return c.Compact(project)
+}
+
+// MentalModel generates an auto-evolving project summary.
+func (e *Engine) MentalModel(project string) (*mental.Model, error) {
+	return mental.Generate(e.store, project)
+}
+
 func (e *Engine) Status(project string) (*Status, error) {
 	nodes, err := e.store.ListNodes(storage.NodeFilter{Project: project})
 	if err != nil {

internal/server/rest.go

@@ -100,6 +100,8 @@ func (s *RESTServer) RegisterRoutes(mux *http.ServeMux) {
 	mux.HandleFunc("GET /yaad/skill/list", s.handleSkillList)
 	mux.HandleFunc("GET /yaad/skill/{name}", s.handleSkillGet)
 	mux.HandleFunc("POST /yaad/bench", s.handleBench)
+	mux.HandleFunc("POST /yaad/compact", s.handleCompact)
+	mux.HandleFunc("GET /yaad/mental-model", s.handleMentalModel)
 }
 
 func (s *RESTServer) handleRemember(w http.ResponseWriter, r *http.Request) {
@@ -538,6 +540,26 @@ func (s *RESTServer) handleBench(w http.ResponseWriter, r *http.Request) {
 	httpJSON(w, map[string]string{"report": result.String()}, 200)
 }
 
+func (s *RESTServer) handleCompact(w http.ResponseWriter, r *http.Request) {
+	project := r.URL.Query().Get("project")
+	n, err := s.eng.Compact(project)
+	if err != nil {
+		httpErr(w, err, 500)
+		return
+	}
+	httpJSON(w, map[string]int{"compacted": n}, 200)
+}
+
+func (s *RESTServer) handleMentalModel(w http.ResponseWriter, r *http.Request) {
+	project := r.URL.Query().Get("project")
+	model, err := s.eng.MentalModel(project)
+	if err != nil {
+		httpErr(w, err, 500)
+		return
+	}
+	httpJSON(w, map[string]any{"model": model, "formatted": model.Format()}, 200)
+}
+
 // --- helpers ---
 
 func httpJSON(w http.ResponseWriter, v any, code int) {