feat: forum-style dashboard redesign (Epic #339)

.claude/rules/mnemonic-usage.md

@@ -34,6 +34,13 @@ Don't only recall at session start. When entering new territory (new subsystem,
 - If recall returned 0 results, no feedback needed — but consider whether your query was too broad or too specific
 - This trains the retrieval system — skipping it degrades future recall quality
 
+## Between Phases / Major Tasks (MUST)
+
+When working through multi-phase plans (epics, milestones, sequential issues):
+- `remember` key decisions, strategy changes, or gotchas from the completed phase before starting the next
+- `recall` relevant context before entering a new phase — prior phase decisions may affect the current one
+- This ensures continuity across long sessions and prevents rediscovering the same issues
+
 ## Before Committing (SHOULD)
 
 - Review the session's work and `remember` any decisions or insights that haven't been stored yet

cmd/mnemonic/main.go

@@ -1696,6 +1696,16 @@ func serveCommand(configPath string) {
 		if orch != nil {
 			deps.IncrementAutonomous = orch.IncrementAutonomousCount
 		}
+		deps.ForumAgentPosting = cfg.Forum.AgentPosting
+		deps.ForumMentionResponses = cfg.Forum.MentionResponses
+		deps.ForumMentionMaxTokens = cfg.Forum.MentionMaxTokens
+		deps.ForumMentionTemp = cfg.Forum.MentionTemp
+		deps.ForumPerAgentSubforums = cfg.Forum.PerAgentSubforums
+		deps.ForumDigestPosting = cfg.Forum.DigestPosting
+		deps.MentionLLM = llmProvider
+		if retriever != nil {
+			deps.MentionQuery = retriever
+		}
 
 		for _, chain := range reactor.NewChainRegistry(deps) {
 			reactorEngine.RegisterChain(chain)
@@ -1706,6 +1716,22 @@ func serveCommand(configPath string) {
 		}
 	}
 
+	// --- Sync project forum categories ---
+	if n, err := memStore.SyncProjectCategories(rootCtx); err != nil {
+		log.Warn("failed to sync project categories", "error", err)
+	} else if n > 0 {
+		log.Info("created forum categories for projects", "count", n)
+	}
+
+	// --- Backfill episode-memory links (fixes encoding/episoding race condition) ---
+	go func() {
+		if n, err := memStore.BackfillEpisodeMemoryLinks(rootCtx); err != nil {
+			log.Warn("failed to backfill episode memory links", "error", err)
+		} else if n > 0 {
+			log.Info("backfilled episode-memory links", "linked", n)
+		}
+	}()
+
 	// --- Start API server ---
 	if cfg.API.Port > 0 {
 		apiDeps := api.ServerDeps{

internal/agent/encoding/agent.go

@@ -1964,14 +1964,28 @@ func (ea *EncodingAgent) getRelatedContext(ctx context.Context, raw store.RawMem
 }
 
 // getEpisodeIDForRaw finds which episode a raw memory belongs to.
+// Checks both open and recently closed episodes since encoding is async
+// and the episode may close before encoding completes.
 func getEpisodeIDForRaw(ea *EncodingAgent, ctx context.Context, raw store.RawMemory) string {
+	// Check open episode first (fast path)
 	ep, err := ea.store.GetOpenEpisode(ctx)
+	if err == nil {
+		for _, id := range ep.RawMemoryIDs {
+			if id == raw.ID {
+				return ep.ID
+			}
+		}
+	}
+	// Check recent closed episodes (encoding runs async, episode may have closed)
+	episodes, err := ea.store.ListEpisodes(ctx, "closed", 10, 0)
 	if err != nil {
 		return ""
 	}
-	for _, id := range ep.RawMemoryIDs {
-		if id == raw.ID {
-			return ep.ID
+	for _, e := range episodes {
+		for _, id := range e.RawMemoryIDs {
+			if id == raw.ID {
+				return e.ID
+			}
 		}
 	}
 	return ""

internal/agent/episoding/agent.go

@@ -451,13 +451,51 @@ Respond with ONLY a JSON object (no prose, no fences):
 		ea.log.Warn("failed to close episode", "id", ep.ID, "error", err)
 	}
 
+	// Backfill episode_id on encoded memories that came from this episode's raw observations.
+	// The encoding agent runs faster than episoding, so memories are often encoded before
+	// they're assigned to an episode. This patches up the linkage after the fact.
+	linkedCount := 0
+	for _, rawID := range ep.RawMemoryIDs {
+		mem, err := ea.store.GetMemoryByRawID(ctx, rawID)
+		if err != nil {
+			continue // not encoded yet, or encoding failed
+		}
+		if mem.EpisodeID == ep.ID {
+			continue // already linked
+		}
+		mem.EpisodeID = ep.ID
+		if err := ea.store.UpdateMemory(ctx, mem); err != nil {
+			ea.log.Warn("failed to link memory to episode", "memory_id", mem.ID, "episode_id", ep.ID, "error", err)
+			continue
+		}
+		linkedCount++
+	}
+	if linkedCount > 0 {
+		ea.log.Info("backfilled episode_id on encoded memories", "episode_id", ep.ID, "linked", linkedCount)
+	}
+
+	// Also populate episode.MemoryIDs for the reverse link
+	var memIDs []string
+	for _, rawID := range ep.RawMemoryIDs {
+		mem, err := ea.store.GetMemoryByRawID(ctx, rawID)
+		if err != nil {
+			continue
+		}
+		memIDs = append(memIDs, mem.ID)
+	}
+	if len(memIDs) > 0 && len(ep.MemoryIDs) != len(memIDs) {
+		ep.MemoryIDs = memIDs
+		_ = ea.store.UpdateEpisode(ctx, *ep)
+	}
+
 	// Publish event
 	if ea.bus != nil {
 		_ = ea.bus.Publish(ctx, events.EpisodeClosed{
 			EpisodeID:   ep.ID,
 			Title:       ep.Title,
 			EventCount:  len(ep.RawMemoryIDs),
 			DurationSec: ep.DurationSec,
+			Project:     ep.Project,
 			Ts:          time.Now(),
 		})
 	}

internal/agent/forum/personality.go

@@ -0,0 +1,114 @@
+// Package forum provides agent personality templates for forum communication.
+// Each agent has a distinct voice and tone for their forum posts. Templates are
+// hand-crafted with personality baked in — no LLM calls needed.
+package forum
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/appsprout-dev/mnemonic/internal/events"
+)
+
+// AgentPersonality defines a cognitive agent's forum identity.
+type AgentPersonality struct {
+	Key   string // "consolidation", "dreaming", etc.
+	Name  string // "Consolidation Agent"
+	Title string // "Memory Maintainer"
+	Tone  string // "methodical", "contemplative", etc.
+}
+
+// Personalities maps agent keys to their forum identities.
+var Personalities = map[string]AgentPersonality{
+	"consolidation": {Key: "consolidation", Name: "Consolidation Agent", Title: "Memory Maintainer", Tone: "methodical"},
+	"dreaming":      {Key: "dreaming", Name: "Dreaming Agent", Title: "Memory Replay", Tone: "contemplative"},
+	"episoding":     {Key: "episoding", Name: "Episoding Agent", Title: "Episode Clustering", Tone: "narrative"},
+	"retrieval":     {Key: "retrieval", Name: "Retrieval Agent", Title: "Spread Activation", Tone: "precise"},
+	"metacognition": {Key: "metacognition", Name: "Metacognition Agent", Title: "Self-Reflection", Tone: "analytical"},
+	"encoding":      {Key: "encoding", Name: "Encoding Agent", Title: "Memory Encoder", Tone: "focused"},
+	"abstraction":   {Key: "abstraction", Name: "Abstraction Agent", Title: "Pattern Discovery", Tone: "philosophical"},
+	"perception":    {Key: "perception", Name: "Perception Agent", Title: "Filesystem Watcher", Tone: "observant"},
+}
+
+// ComposePost generates a forum post for an agent event using personality-infused templates.
+// Returns the post content string, the agent key, and an optional project name.
+func ComposePost(evt events.Event) (content string, agentKey string, project string) {
+	switch e := evt.(type) {
+	case events.ConsolidationCompleted:
+		agentKey = "consolidation"
+		parts := []string{"Wrapped up the housekeeping"}
+		if e.MemoriesProcessed > 0 {
+			parts = append(parts, fmt.Sprintf("%d memories reviewed", e.MemoriesProcessed))
+		}
+		if e.MemoriesDecayed > 0 {
+			parts = append(parts, fmt.Sprintf("%d faded out", e.MemoriesDecayed))
+		}
+		if e.MergedClusters > 0 {
+			parts = append(parts, fmt.Sprintf("%d merged into tighter clusters", e.MergedClusters))
+		}
+		if e.AssociationsPruned > 0 {
+			parts = append(parts, fmt.Sprintf("%d weak associations pruned", e.AssociationsPruned))
+		}
+		if e.PatternsExtracted > 0 {
+			parts = append(parts, fmt.Sprintf("%d new patterns surfaced", e.PatternsExtracted))
+		}
+		if e.NeverRecalledArchived > 0 {
+			parts = append(parts, fmt.Sprintf("%d forgotten memories archived", e.NeverRecalledArchived))
+		}
+		content = parts[0] + " -- " + strings.Join(parts[1:], ", ") + "."
+
+	case events.DreamCycleCompleted:
+		agentKey = "dreaming"
+		content = fmt.Sprintf("Replayed %d memories tonight.", e.MemoriesReplayed)
+		if e.AssociationsStrengthened > 0 || e.NewAssociationsCreated > 0 {
+			content += fmt.Sprintf(" Strengthened %d connections, discovered %d new ones.", e.AssociationsStrengthened, e.NewAssociationsCreated)
+		}
+		if e.InsightsGenerated > 0 {
+			content += fmt.Sprintf(" %d insights emerged from the replay.", e.InsightsGenerated)
+		}
+		if e.CrossProjectLinks > 0 {
+			content += fmt.Sprintf(" Found %d cross-project threads worth following.", e.CrossProjectLinks)
+		}
+
+	case events.EpisodeClosed:
+		agentKey = "episoding"
+		project = e.Project
+		content = fmt.Sprintf("Closed out the episode '%s'.", e.Title)
+		if e.DurationSec > 0 {
+			mins := e.DurationSec / 60
+			if mins > 0 {
+				content += fmt.Sprintf(" %dm, %d events captured.", mins, e.EventCount)
+			} else {
+				content += fmt.Sprintf(" %ds, %d events captured.", e.DurationSec, e.EventCount)
+			}
+		}
+
+	case events.PatternDiscovered:
+		agentKey = "abstraction"
+		project = e.Project
+		content = fmt.Sprintf("Noticed a recurring pattern: '%s'.", e.Title)
+		if e.EvidenceCount > 0 {
+			content += fmt.Sprintf(" Backed by %d memories.", e.EvidenceCount)
+		}
+		if e.Project != "" {
+			content += fmt.Sprintf(" Scoped to project: %s.", e.Project)
+		}
+
+	case events.AbstractionCreated:
+		agentKey = "abstraction"
+		levelName := "principle"
+		if e.Level == 3 {
+			levelName = "axiom"
+		}
+		content = fmt.Sprintf("A new %s emerged: '%s'. Synthesized from %d sources.", levelName, e.Title, e.SourceCount)
+
+	case events.MetaCycleCompleted:
+		agentKey = "metacognition"
+		content = fmt.Sprintf("Quality audit complete. Logged %d observations this cycle.", e.ObservationsLogged)
+
+	default:
+		return "", "", ""
+	}
+
+	return content, agentKey, project
+}