feat(agent): persist conversation tree via a Store seam + in-memory Store (Wave 2)

[urmzd]

Wave 2 — Durability spine

Wires agent tree persistence behind the existing types.Store seam, fully testable without Postgres. This is a bounded, green slice: the in-memory-only path is byte-for-byte unchanged, and a configured Store now durably records the conversation tree.

Stacked on #38 (foundation) — merge after #38.

What landed (with tests)

agent package

• AgentConfig.Store types.Store + WithStore(...) option. Default nil preserves today's in-memory-only behavior (fully backward compatible).
• runLoop persists every new node and its branch tip as it is added — at all four AddChild sites (input messages, assistant message, tool-result message, handoff overlay). Persistence goes through Store.Tx so a reader never observes a branch tip pointing at an unsaved node. It is best-effort: a nil Store is a no-op, and any error is logged (slog.Warn), never fatal — a persistence failure cannot break a live run.
• NewAgent persists the root node + main branch up front when a Store is configured, so LoadTreeFromStore has an anchor even before the first Invoke.
• LoadTreeFromStore(ctx, store, rootID, active) helper: the read/resume counterpart, built on Store.LoadTree + tree.FromStore. Pass the rebuilt tree to NewAgent via WithTree to resume a persisted session.

New package agent/store/memstore

• In-memory types.Store implementing the full interface: SaveNode, LoadNode, LoadChildren, LoadPath, SaveBranch, LoadBranch, ListBranches, SaveCheckpoint, LoadCheckpoint, LoadTree, Tx.
• Concurrency-safe (RWMutex); nodes are defensively copied in and out so callers cannot mutate stored state.
• LoadTree returns only the subtree reachable from rootID (BFS over child-order), ordered root-first — mirroring pgstore's recursive descendant query closely enough for tree.FromStore.
• Tx buffers writes and applies them atomically on success; on error nothing is persisted (all-or-nothing, matching pgstore's DB transaction).

Tests

• agent/store/memstore/memstore_test.go — table/unit tests: save/load round-trip, returned-pointer isolation, child insertion order, path, branches, checkpoints, reachable-subtree LoadTree, and Tx commit + rollback.
• agent/agent_store_test.go:
  • TestStoreMultiTurnRoundTrip — build an agent with a memstore, run two Invoke turns, reconstruct the tree purely from the Store (LoadTreeFromStore → FromStore → LoadTree), and assert the full flattened message history round-trips message-for-message (plus content spot-checks).
  • TestStoreNilIsBackwardCompatible — no Store: default nil, Invoke still populates the tree.
  • TestStorePersistsRootOnConstruction — root node + main branch are written at construction.

Green

• go build ./... ✅
• go vet ./agent/ ./agent/store/memstore/ ✅
• go test ./agent/ ./agent/store/memstore/ ✅ (also ran ./agent/tree/)
• gofmt clean.
• Did not run the full go test ./... (rag/kg packages download embedding models).

Deferred (TODO, beyond this slice)

• agent/pgstore transactional per-turn wiring (this slice only added the in-memory Store + the generic Store-agnostic persistence in runLoop; pgstore already implements the interface but is not yet exercised per-turn here).
• Versioned migrator for the agent schema.
• RAG/KG ingest transactions.
• BM25 rebuild-on-boot.
• Postgres integration tests.
• Optional convenience: a WithStore-driven auto-hydrate path inside NewAgent (currently hydration is explicit via LoadTreeFromStore + WithTree, kept simple and correct).

[urmzd]

Superseded by #44, which was squash-merged into main (53a6aff) and contains every change from this branch — a dry merge of this branch into main is a no-op. main is green (build/vet/golangci-lint, 39 packages, and 8/8 live validation on gpt-4o-mini). Closing as redundant.