maven: scheduled routines + persistent long-term memory

Two additive proactive/recall features.

Routines (internal/routine): a third proactive class beside reminders
(user-stated) and care rules (world-state) — operator-declared clockwork.
config.routines[] (cron + literal RU body + severity) fire through the
normal dispatcher on schedule. Bodies are literal, not LLM-phrased (can't
hallucinate); rule name routine:<name> keeps them out of the care
autotuner; a cold-start guard seeds on first sight so a restart never
replays a missed schedule. Pure routine.Due + config validation, unit-
tested; the tick driver holds the last-fired map and calls fireRoutines.

Persistent memory (internal/store/memory.go): store.MemoryStore backs the
memory.Store interface with the SAME encrypted sqlite db — survives
restarts and recall text inherits at-rest encryption (no plaintext
sidecar). float32-blob vectors, brute-force cosine (ANN is a later swap
behind the interface), upsert-by-id. The daemon wires st.VectorMemory()
into wireVoice; the in-memory impl stays the test/no-store floor. Closes
the "in-memory only, lost on restart" gap (PROGRESS #8).

Gate green: gofmt/vet clean, -race across routine/config/store/mavend.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01U2PNdwDj2Gt8YW294J7oSc

cmd/mavend/tick_test.go

@@ -10,6 +10,7 @@ import (
 	"github.com/kami/maven/internal/delivery"
 	"github.com/kami/maven/internal/loop"
 	"github.com/kami/maven/internal/phraser"
+	"github.com/kami/maven/internal/routine"
 	"github.com/kami/maven/internal/store"
 )
 
@@ -45,7 +46,54 @@ func newTestTickLoop(t *testing.T, st *store.Store, sink delivery.Sink, digestCf
 		Nudges:    st,
 		Reminders: st,
 	})
-	return newTickLoop(st, g, d, phraser.NewStub(), rules, time.Second, 5*time.Minute, 0, digestCfg)
+	return newTickLoop(st, g, d, phraser.NewStub(), rules, time.Second, 5*time.Minute, 0, digestCfg, nil)
+}
+
+func TestTickFiresRoutineWhenScheduleCrosses(t *testing.T) {
+	// A routine scheduled for 12:00 daily. On the first tick it seeds (cold-start
+	// guard — no fire); on a tick past the next 12:00 crossing it fires through
+	// the dispatcher with its literal body and severity.
+	st := newTestStore(t)
+	ctx := context.Background()
+	now := refNow() // 2026-06-30 12:00 UTC
+	markPresent(t, st, ctx, now)
+
+	rules := loop.DefaultRules()
+	g := loop.NewGatherer(st, rules)
+	sink := &fakeSink{}
+	d := delivery.NewDispatcher(delivery.Config{Voice: sink, Ntfy: sink, Telegram: sink, Nudges: st, Reminders: st})
+	rs := []routine.Routine{{Name: "morning", Cron: "0 12 * * *", Body: "полдень, время воды", Severity: 1}}
+	tl := newTickLoop(st, g, d, phraser.NewStub(), rules, time.Second, 5*time.Minute, 0, nil, rs)
+
+	// first tick: seeds, does not fire the routine.
+	tl.tick(ctx, now)
+	for _, s := range sink.sends {
+		if s.RuleName == "routine:morning" {
+			t.Fatal("routine fired on the seeding tick (cold-start guard failed)")
+		}
+	}
+
+	// next day, just past 12:00 — the schedule crossed.
+	next := now.Add(24 * time.Hour).Add(time.Minute)
+	markPresent(t, st, ctx, next)
+	sink.sends = nil
+	tl.tick(ctx, next)
+
+	var got *delivery.Sendable
+	for i := range sink.sends {
+		if sink.sends[i].RuleName == "routine:morning" {
+			got = &sink.sends[i]
+		}
+	}
+	if got == nil {
+		t.Fatalf("routine did not fire after its schedule crossed; sends=%+v", sink.sends)
+	}
+	if got.Body != "полдень, время воды" {
+		t.Errorf("routine body = %q, want the literal config body", got.Body)
+	}
+	if got.Channel != delivery.ChannelVoice {
+		t.Errorf("routine channel = %v, want voice (sev1 present)", got.Channel)
+	}
 }
 
 // refNow — fixed tick time so presence decay + since durations are deterministic.