Render maven's own reminders to a calendar she owns (#127)

Radicale becomes a write-only render target, not a store. sqlite stays
canonical: every poll mavcaldav reads the pending reminders out of core and
publishes each one as a single-event iCal resource, withdrawing the ones that
have fired or been cancelled. Losing the collection costs nothing — the next
tick rebuilds it, and nothing is ever read back from it.

It structurally cannot write to a calendar maven only reads. The render URL and
credential are their own flags, and -render-url is refused at startup when it
names the collection -url reads; the only paths it addresses carry the
maven-reminder- prefix, so even aimed at the wrong collection it can only touch
resources it created. Rendering is off unless -render-url is given.

The calendar data model now lives in one place, internal/calendar: the Event,
the iCal parse it comes from and the render it goes to, the fact key/value
encoding, and the source constants that say which calendars may be written to.
It was a parse inlined in cmd/mavcaldav and a Sprintf in two files; #126 and
#128 both need to agree with it.

Fixes a latent day-boundary bug moved out of that inline parse: it took the day
number off a local clock reading but built the window boundaries in UTC, so on
a box east of Greenwich part of the evening fell outside "today" and the poller
saw an empty calendar after 20:00 UTC. Today is now the owner's day in the
owner's location, which is what the busy gate and the day plan mean.

cmd/mavcaldav/main.go

@@ -1,17 +1,24 @@
-// mavcaldav — the CalDAV poller module.
+// mavcaldav — the CalDAV module: reads calendars into facts, and renders
+// maven's own reminders back out to a calendar she owns.
 //
-// Polls a Radicale (or any CalDAV) server for today's events and writes
-// `facts (kind=env, source=poll:caldav)` through core's IPC socket.
-// Key-free, restart-free, fail-independent — crashes can't touch the
-// store key, worst case a stale calendar_busy fact until the next poll.
+// READ side (unchanged behaviour): polls a Radicale (or any CalDAV) server for
+// today's events and writes `facts (kind=env, source=poll:caldav)` through
+// core's IPC socket. Key-free, restart-free, fail-independent — crashes can't
+// touch the store key, worst case a stale calendar_busy fact until the next
+// poll. Two facts:
 //
-// Two facts written:
 //   - calendar_busy  ("true"/"false") — read by the loop gate to suppress
 //     nudges during meetings
 //   - calendar_event ("<summary> @ <start>-<end>") — per-event for query
 //
-// Append-only discipline: a fact is written only when its value CHANGED
-// vs the latest for that key+source.
+// Append-only discipline: a fact is written only when its value CHANGED vs the
+// latest for that key+source.
+//
+// RENDER side (Vikunja #127, off unless -render-url is given): publishes each
+// pending reminder as a single-event iCal resource in a collection maven owns.
+// The calendar is a view, sqlite is the store — see render.go. The render URL
+// must differ from the read URL, checked at startup, so the render target can
+// never be a calendar maven is only supposed to read.
 package main
 
 import (
@@ -27,6 +34,7 @@ import (
 	"syscall"
 	"time"
 
+	"github.com/kami/maven/internal/calendar"
 	"github.com/kami/maven/internal/ipc"
 )
 
@@ -43,6 +51,10 @@ func run(args []string) error {
 	url := fs.String("url", "", "CalDAV calendar URL, e.g. http://localhost:5232/kami/personal (required)")
 	user := fs.String("user", "", "CalDAV basic-auth username (required)")
 	pass := fs.String("pass", "", "CalDAV basic-auth password (required)")
+	renderURL := fs.String("render-url", "", "CalDAV collection maven publishes her own reminders to; empty disables rendering")
+	renderUser := fs.String("render-user", "", "basic-auth username for -render-url (defaults to -user)")
+	renderPass := fs.String("render-pass", "", "basic-auth password for -render-url (defaults to -pass)")
+	renderDur := fs.Duration("render-duration", calendar.DefaultReminderDuration, "how long a rendered reminder occupies")
 	interval := fs.Duration("interval", 5*time.Minute, "poll cadence")
 	timeout := fs.Duration("timeout", 10*time.Second, "per-request HTTP timeout")
 	if err := fs.Parse(args); err != nil {
@@ -54,6 +66,9 @@ func run(args []string) error {
 	if *url == "" || *user == "" || *pass == "" {
 		return fmt.Errorf("-url, -user, -pass are required")
 	}
+	if err := checkRenderTarget(*url, *renderURL); err != nil {
+		return err
+	}
 
 	ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
 	defer stop()
@@ -64,16 +79,36 @@ func run(args []string) error {
 	}
 	defer core.Close()
 
+	hc := &http.Client{Timeout: *timeout}
 	p := &poller{
 		core: core,
-		http: &http.Client{Timeout: *timeout},
+		http: hc,
 		url:  strings.TrimRight(*url, "/"),
 		user: *user,
 		pass: *pass,
 	}
 
+	var rend *renderer
+	if *renderURL != "" {
+		ru, rp := *renderUser, *renderPass
+		if ru == "" {
+			ru = *user
+		}
+		if rp == "" {
+			rp = *pass
+		}
+		rend = newRenderer(core, hc, *renderURL, ru, rp, *renderDur)
+		log.Printf("mavcaldav: rendering reminders to %s", *renderURL)
+	}
+
 	log.Printf("mavcaldav: polling %s every %s", *url, *interval)
-	p.pollOnce(ctx) // fire immediately
+	tick := func() {
+		p.pollOnce(ctx)
+		if rend != nil {
+			rend.renderOnce(ctx)
+		}
+	}
+	tick() // fire immediately
 	t := time.NewTicker(*interval)
 	defer t.Stop()
 	for {
@@ -82,11 +117,30 @@ func run(args []string) error {
 			log.Printf("mavcaldav: bye")
 			return nil
 		case <-t.C:
-			p.pollOnce(ctx)
+			tick()
 		}
 	}
 }
 
+// checkRenderTarget refuses a render URL that is also a read URL. This is the
+// structural half of #127's "cannot write to your work calendar": the write
+// credential and the write URL are separate flags, and the one calendar maven
+// is known to only read is rejected as a target at startup rather than trusted
+// at runtime.
+func checkRenderTarget(readURL, renderURL string) error {
+	if renderURL == "" {
+		return nil
+	}
+	if sameCollection(readURL, renderURL) {
+		return fmt.Errorf("-render-url must differ from -url: maven renders into a calendar she owns, never into one she reads")
+	}
+	return nil
+}
+
+func sameCollection(a, b string) bool {
+	return strings.EqualFold(strings.TrimRight(a, "/"), strings.TrimRight(b, "/"))
+}
+
 type poller struct {
 	core ipc.CoreAPI
 	http *http.Client
@@ -95,12 +149,6 @@ type poller struct {
 	pass string
 }
 
-type icalEvent struct {
-	start   time.Time
-	end     time.Time
-	summary string
-}
-
 func (p *poller) pollOnce(ctx context.Context) {
 	now := time.Now()
 	events, err := p.fetchEvents(ctx, now)
@@ -109,38 +157,30 @@ func (p *poller) pollOnce(ctx context.Context) {
 		return
 	}
 
-	busy := false
-	for _, e := range events {
-		if !now.Before(e.start) && now.Before(e.end) {
-			busy = true
-			break
-		}
-	}
 	busyVal := "false"
-	if busy {
+	if calendar.Busy(events, now) {
 		busyVal = "true"
 	}
 
 	// Write calendar_busy on change.
-	if err := p.writeIfChanged(ctx, "calendar_busy", "poll:caldav", busyVal, now); err != nil {
+	if err := p.writeIfChanged(ctx, "calendar_busy", calendar.SourcePersonal, busyVal, now, 1.0); err != nil {
 		log.Printf("mavcaldav: write calendar_busy: %v", err)
 		return
 	}
 
-	// Write per-event facts (one per event, keyed by event summary + start).
+	// Write per-event facts (one per event, keyed by day + event summary).
 	// This lets the note RAG path answer "what's on my calendar" without
 	// reaching back to Radicale.
 	for _, e := range events {
-		val := fmt.Sprintf("%s @ %s-%s", e.summary, e.start.Format("15:04"), e.end.Format("15:04"))
-		eventKey := fmt.Sprintf("calendar_event_%s_%s", e.start.Format("20060102"), safeKey(e.summary))
-		if err := p.writeIfChanged(ctx, eventKey, "poll:caldav", val, e.start); err != nil {
-			log.Printf("mavcaldav: write %s: %v", eventKey, err)
+		key := calendar.FactKey(e)
+		if err := p.writeIfChanged(ctx, key, calendar.SourcePersonal, calendar.FactValue(e), e.Start, 1.0); err != nil {
+			log.Printf("mavcaldav: write %s: %v", key, err)
 		}
 	}
 }
 
 // fetchEvents GETs the calendar URL and parses VEVENTs from the iCal response.
-func (p *poller) fetchEvents(ctx context.Context, now time.Time) ([]icalEvent, error) {
+func (p *poller) fetchEvents(ctx context.Context, now time.Time) ([]calendar.Event, error) {
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, p.url, nil)
 	if err != nil {
 		return nil, err
@@ -162,120 +202,11 @@ func (p *poller) fetchEvents(ctx context.Context, now time.Time) ([]icalEvent, e
 		return nil, fmt.Errorf("GET %s: %s", p.url, resp.Status)
 	}
 
-	return parseICal(body, now), nil
-}
-
-// parseICal scans iCal text for VEVENT components. Returns events that overlap
-// with today (UTC day boundaries) to keep the response manageable.
-func parseICal(body []byte, now time.Time) []icalEvent {
-	todayStart := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, time.UTC)
-	todayEnd := todayStart.AddDate(0, 0, 1)
-
-	var events []icalEvent
-	text := string(body)
-	for {
-		veventStart := strings.Index(text, "BEGIN:VEVENT")
-		if veventStart < 0 {
-			break
-		}
-		text = text[veventStart+len("BEGIN:VEVENT"):]
-		veventEnd := strings.Index(text, "END:VEVENT")
-		if veventEnd < 0 {
-			break
-		}
-		block := text[:veventEnd]
-		text = text[veventEnd+len("END:VEVENT"):]
-
-		e := parseVEVENT(block)
-		if e == nil {
-			continue
-		}
-		// Only keep events overlapping today.
-		if e.end.After(todayStart) && e.start.Before(todayEnd) {
-			events = append(events, *e)
-		}
-	}
-	return events
-}
-
-// parseVEVENT extracts start, end, summary from a VEVENT block.
-// Supports both UTC (DTEND:20260703T100000Z) and local (DTSTART;TZID=...:...)
-// formats. Returns nil for all-day events (no DTSTART/DTEND time component) or
-// parse failures.
-func parseVEVENT(block string) *icalEvent {
-	var e icalEvent
-	lines := strings.Split(block, "\n")
-	for _, line := range lines {
-		line = strings.TrimSpace(line)
-		switch {
-		case strings.HasPrefix(line, "DTSTART"):
-			if t, ok := parseDT(line); ok {
-				e.start = t
-			}
-		case strings.HasPrefix(line, "DTEND"):
-			if t, ok := parseDT(line); ok {
-				e.end = t
-			}
-		case strings.HasPrefix(line, "SUMMARY"):
-			if idx := strings.Index(line, ":"); idx >= 0 {
-				e.summary = strings.TrimSpace(line[idx+1:])
-			}
-		}
-	}
-	if e.start.IsZero() || e.end.IsZero() {
-		return nil
-	}
-	return &e
-}
-
-// parseDT parses a DTSTART/DTEND value. Supports:
-//   - UTC: DTEND:20260703T100000Z
-//   - Local: DTSTART;TZID=Europe/Moscow:20260703T130000
-//   - Value-date (all-day): DTSTART;VALUE=DATE:20260703 (returns zero time)
-func parseDT(line string) (time.Time, bool) {
-	if strings.Contains(line, "VALUE=DATE:") {
-		return time.Time{}, false // all-day, skip
-	}
-	idx := strings.LastIndex(line, ":")
-	if idx < 0 {
-		return time.Time{}, false
-	}
-	val := line[idx+1:]
-	val = strings.TrimSuffix(val, "Z")
-
-	// Try UTC first (has Z suffix, or ended in Z before TrimSuffix).
-	if strings.HasSuffix(line, "Z") {
-		t, err := time.Parse("20060102T150405", val)
-		if err != nil {
-			return time.Time{}, false
-		}
-		return t.UTC(), true
-	}
-
-	// Local time — treat as UTC for simplicity (CalDAV server and poller
-	// run in the same timezone; the gate only needs busy/not-busy accuracy).
-	t, err := time.Parse("20060102T150405", val)
-	if err != nil {
-		return time.Time{}, false
-	}
-	return t.UTC(), true
-}
-
-// safeKey makes an event summary safe to use as a fact key (alphanumeric + dash).
-func safeKey(s string) string {
-	var b strings.Builder
-	for _, r := range s {
-		if (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') || (r >= '0' && r <= '9') || r == '-' {
-			b.WriteRune(r)
-		} else if r == ' ' || r == '_' {
-			b.WriteRune('-')
-		}
-	}
-	return b.String()
+	return calendar.ParseICalDay(body, now), nil
 }
 
 // writeIfChanged writes a fact only when the value differs from the latest.
-func (p *poller) writeIfChanged(ctx context.Context, key, source, val string, ts time.Time) error {
+func (p *poller) writeIfChanged(ctx context.Context, key, source, val string, ts time.Time, confidence float64) error {
 	prev, err := p.core.LatestFactBySource(ctx, key, source)
 	switch {
 	case err == nil && prev.Value == val:
@@ -289,7 +220,7 @@ func (p *poller) writeIfChanged(ctx context.Context, key, source, val string, ts
 		Key:        key,
 		Value:      val,
 		Source:     source,
-		Confidence: 1.0,
+		Confidence: confidence,
 	})
 	if err != nil {
 		return fmt.Errorf("write %s: %w", key, err)

cmd/mavcaldav/main_test.go

@@ -51,165 +51,6 @@ func (f *fakeCore) WriteFact(_ context.Context, req ipc.WriteFactReq) (int64, er
 	return int64(len(f.writeLog)), nil
 }
 
-// ---------------------------------------------------------------------------
-// Parsing tests
-// ---------------------------------------------------------------------------
-
-func TestParseICal(t *testing.T) {
-	now := time.Date(2026, 7, 3, 12, 0, 0, 0, time.UTC)
-
-	body := []byte(`BEGIN:VCALENDAR
-BEGIN:VEVENT
-DTSTART:20260703T090000Z
-DTEND:20260703T100000Z
-SUMMARY:Morning standup
-END:VEVENT
-BEGIN:VEVENT
-DTSTART:20260703T140000Z
-DTEND:20260703T150000Z
-SUMMARY:Team sync
-END:VEVENT
-BEGIN:VEVENT
-DTSTART:20260702T140000Z
-DTEND:20260702T150000Z
-SUMMARY:Yesterday retro
-END:VEVENT
-BEGIN:VEVENT
-DTSTART:20260704T090000Z
-DTEND:20260704T100000Z
-SUMMARY:Tomorrow standup
-END:VEVENT
-BEGIN:VEVENT
-DTSTART;VALUE=DATE:20260704
-DTEND;VALUE=DATE:20260705
-SUMMARY:All-day event
-END:VEVENT
-END:VCALENDAR`)
-
-	events := parseICal(body, now)
-
-	if len(events) != 2 {
-		t.Fatalf("got %d events, want 2 (today events, no all-day/past/future)", len(events))
-	}
-
-	// Morning standup — overlaps today.
-	if events[0].summary != "Morning standup" {
-		t.Errorf("events[0].summary = %q, want %q", events[0].summary, "Morning standup")
-	}
-	wantStart0 := time.Date(2026, 7, 3, 9, 0, 0, 0, time.UTC)
-	if !events[0].start.Equal(wantStart0) {
-		t.Errorf("events[0].start = %v, want %v", events[0].start, wantStart0)
-	}
-	wantEnd0 := time.Date(2026, 7, 3, 10, 0, 0, 0, time.UTC)
-	if !events[0].end.Equal(wantEnd0) {
-		t.Errorf("events[0].end = %v, want %v", events[0].end, wantEnd0)
-	}
-
-	// Team sync — overlaps today.
-	if events[1].summary != "Team sync" {
-		t.Errorf("events[1].summary = %q, want %q", events[1].summary, "Team sync")
-	}
-	wantStart1 := time.Date(2026, 7, 3, 14, 0, 0, 0, time.UTC)
-	if !events[1].start.Equal(wantStart1) {
-		t.Errorf("events[1].start = %v, want %v", events[1].start, wantStart1)
-	}
-	wantEnd1 := time.Date(2026, 7, 3, 15, 0, 0, 0, time.UTC)
-	if !events[1].end.Equal(wantEnd1) {
-		t.Errorf("events[1].end = %v, want %v", events[1].end, wantEnd1)
-	}
-}
-
-func TestParseVEVENT(t *testing.T) {
-	// Normal event with TZID in DTSTART and UTC DTEND.
-	block := "DTSTART;TZID=Europe/Moscow:20260703T130000\nDTEND:20260703T140000Z\nSUMMARY:Stand up meeting"
-	e := parseVEVENT(block)
-	if e == nil {
-		t.Fatal("expected non-nil icalEvent")
-	}
-	wantStart := time.Date(2026, 7, 3, 13, 0, 0, 0, time.UTC)
-	if !e.start.Equal(wantStart) {
-		t.Errorf("start = %v, want %v", e.start, wantStart)
-	}
-	wantEnd := time.Date(2026, 7, 3, 14, 0, 0, 0, time.UTC)
-	if !e.end.Equal(wantEnd) {
-		t.Errorf("end = %v, want %v", e.end, wantEnd)
-	}
-	if e.summary != "Stand up meeting" {
-		t.Errorf("summary = %q, want %q", e.summary, "Stand up meeting")
-	}
-
-	// All-day event (VALUE=DATE) → nil.
-	allDay := "DTSTART;VALUE=DATE:20260703\nDTEND;VALUE=DATE:20260704\nSUMMARY:All-day"
-	if e2 := parseVEVENT(allDay); e2 != nil {
-		t.Error("expected nil for all-day event")
-	}
-}
-
-func TestParseDT(t *testing.T) {
-	tests := []struct {
-		name   string
-		line   string
-		want   time.Time
-		wantOK bool
-	}{
-		{
-			name:   "UTC",
-			line:   "DTEND:20260703T100000Z",
-			want:   time.Date(2026, 7, 3, 10, 0, 0, 0, time.UTC),
-			wantOK: true,
-		},
-		{
-			name:   "local time",
-			line:   "DTSTART;TZID=Europe/Moscow:20260703T130000",
-			want:   time.Date(2026, 7, 3, 13, 0, 0, 0, time.UTC),
-			wantOK: true,
-		},
-		{
-			name:   "all-day",
-			line:   "DTSTART;VALUE=DATE:20260703",
-			want:   time.Time{},
-			wantOK: false,
-		},
-		{
-			name:   "invalid",
-			line:   "DTSTART:garbage",
-			want:   time.Time{},
-			wantOK: false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got, ok := parseDT(tt.line)
-			if ok != tt.wantOK {
-				t.Errorf("ok = %v, want %v", ok, tt.wantOK)
-			}
-			if !got.Equal(tt.want) {
-				t.Errorf("got = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}
-
-func TestSafeKey(t *testing.T) {
-	tests := []struct {
-		input string
-		want  string
-	}{
-		{"Stand up meeting", "Stand-up-meeting"},
-		{"Hello_World", "Hello-World"},
-		{"special@#$chars!!", "specialchars"},
-		{"ALL_CAPS_123", "ALL-CAPS-123"},
-	}
-
-	for _, tt := range tests {
-		got := safeKey(tt.input)
-		if got != tt.want {
-			t.Errorf("safeKey(%q) = %q, want %q", tt.input, got, tt.want)
-		}
-	}
-}
-
 // ---------------------------------------------------------------------------
 // Core logic tests
 // ---------------------------------------------------------------------------
@@ -221,7 +62,7 @@ func TestWriteIfChanged(t *testing.T) {
 	t.Run("no previous fact writes", func(t *testing.T) {
 		fc := &fakeCore{}
 		p := &poller{core: fc}
-		err := p.writeIfChanged(ctx, "test_key", "poll:caldav", "hello", now)
+		err := p.writeIfChanged(ctx, "test_key", "poll:caldav", "hello", now, 1.0)
 		if err != nil {
 			t.Fatalf("unexpected error: %v", err)
 		}
@@ -249,7 +90,7 @@ func TestWriteIfChanged(t *testing.T) {
 			},
 		}
 		p := &poller{core: fc}
-		err := p.writeIfChanged(ctx, "test_key", "poll:caldav", "hello", now)
+		err := p.writeIfChanged(ctx, "test_key", "poll:caldav", "hello", now, 1.0)
 		if err != nil {
 			t.Fatalf("unexpected error: %v", err)
 		}
@@ -265,7 +106,7 @@ func TestWriteIfChanged(t *testing.T) {
 			},
 		}
 		p := &poller{core: fc}
-		err := p.writeIfChanged(ctx, "test_key", "poll:caldav", "new", now)
+		err := p.writeIfChanged(ctx, "test_key", "poll:caldav", "new", now, 1.0)
 		if err != nil {
 			t.Fatalf("unexpected error: %v", err)
 		}
@@ -280,7 +121,7 @@ func TestWriteIfChanged(t *testing.T) {
 	t.Run("read error other than ErrNoFact returns error", func(t *testing.T) {
 		fc := &fakeCore{readErr: fmt.Errorf("connection refused")}
 		p := &poller{core: fc}
-		err := p.writeIfChanged(ctx, "fail_key", "poll:caldav", "x", now)
+		err := p.writeIfChanged(ctx, "fail_key", "poll:caldav", "x", now, 1.0)
 		if err == nil {
 			t.Fatal("expected error, got nil")
 		}
@@ -292,7 +133,7 @@ func TestWriteIfChanged(t *testing.T) {
 			writeErr: fmt.Errorf("disk full"),
 		}
 		p := &poller{core: fc}
-		err := p.writeIfChanged(ctx, "test_key", "poll:caldav", "hello", now)
+		err := p.writeIfChanged(ctx, "test_key", "poll:caldav", "hello", now, 1.0)
 		if err == nil {
 			t.Fatal("expected error, got nil")
 		}

cmd/mavcaldav/render.go

@@ -0,0 +1,145 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/kami/maven/internal/calendar"
+	"github.com/kami/maven/internal/ipc"
+)
+
+// renderer is the write half of maven's own local calendar (Vikunja #127).
+//
+// It is a RENDER TARGET, not a store. sqlite stays canonical: every tick the
+// renderer reads the pending reminders out of core and publishes each one as a
+// single-event iCal resource in a CalDAV collection maven owns. Nothing is ever
+// read back from that collection, and losing it costs nothing — the next tick
+// rebuilds it.
+//
+// It structurally cannot write to a calendar maven only reads. The URL comes
+// from its own flag, checked at startup against every read URL (see
+// run in main.go), and the only paths it ever addresses carry
+// calendar.ReminderUIDPrefix — so even pointed at the wrong collection it can
+// only touch resources it created.
+type renderer struct {
+	core ipc.CoreAPI
+	http *http.Client
+	url  string
+	user string
+	pass string
+	dur  time.Duration
+
+	// published maps reminder id → the body last successfully PUT, so an
+	// unchanged reminder costs nothing. Purely an optimisation: a restart
+	// re-publishes every reminder once, which is idempotent.
+	published map[int64]string
+}
+
+func newRenderer(core ipc.CoreAPI, hc *http.Client, url, user, pass string, dur time.Duration) *renderer {
+	return &renderer{
+		core:      core,
+		http:      hc,
+		url:       strings.TrimRight(url, "/"),
+		user:      user,
+		pass:      pass,
+		dur:       dur,
+		published: make(map[int64]string),
+	}
+}
+
+// renderOnce publishes every pending reminder and withdraws the ones that are
+// no longer pending. Errors are logged and skipped: a calendar maven cannot
+// reach must never break the reminder itself, which lives in sqlite.
+func (r *renderer) renderOnce(ctx context.Context) {
+	reminders, err := r.core.ListReminders(ctx, renderMaxReminders)
+	if err != nil {
+		log.Printf("mavcaldav: list reminders: %v", err)
+		return
+	}
+
+	live := make(map[int64]bool, len(reminders))
+	for _, rem := range reminders {
+		if rem.Status != "pending" {
+			continue
+		}
+		live[rem.ID] = true
+		e := calendar.ReminderEvent(rem.ID, fireTime(rem), rem.Payload, r.dur)
+		body := calendar.RenderICal([]calendar.Event{e})
+		if r.published[rem.ID] == body {
+			continue
+		}
+		if err := r.put(ctx, calendar.ReminderPath(rem.ID), body); err != nil {
+			log.Printf("mavcaldav: render reminder %d: %v", rem.ID, err)
+			continue
+		}
+		r.published[rem.ID] = body
+		log.Printf("mavcaldav: rendered reminder %d (%s)", rem.ID, e.Summary)
+	}
+
+	for id := range r.published {
+		if live[id] {
+			continue
+		}
+		if err := r.delete(ctx, calendar.ReminderPath(id)); err != nil {
+			log.Printf("mavcaldav: withdraw reminder %d: %v", id, err)
+			continue
+		}
+		delete(r.published, id)
+		log.Printf("mavcaldav: withdrew reminder %d", id)
+	}
+}
+
+// renderMaxReminders bounds the read. Reminders past this count are older than
+// anything a calendar view is useful for.
+const renderMaxReminders = 200
+
+// fireTime prefers NextFireTs — for a recurring reminder that is the occurrence
+// worth showing; FireTs is the original statement.
+func fireTime(rem ipc.Reminder) time.Time {
+	if !rem.NextFireTs.IsZero() {
+		return rem.NextFireTs
+	}
+	return rem.FireTs
+}
+
+func (r *renderer) put(ctx context.Context, name, body string) error {
+	req, err := http.NewRequestWithContext(ctx, http.MethodPut, r.url+"/"+name, strings.NewReader(body))
+	if err != nil {
+		return err
+	}
+	req.SetBasicAuth(r.user, r.pass)
+	req.Header.Set("Content-Type", "text/calendar; charset=utf-8")
+	return r.do(req, name)
+}
+
+func (r *renderer) delete(ctx context.Context, name string) error {
+	req, err := http.NewRequestWithContext(ctx, http.MethodDelete, r.url+"/"+name, nil)
+	if err != nil {
+		return err
+	}
+	req.SetBasicAuth(r.user, r.pass)
+	return r.do(req, name)
+}
+
+// do runs the request and treats any 2xx, plus 404 on a DELETE, as success —
+// a resource that is already gone is the state the caller wanted.
+func (r *renderer) do(req *http.Request, name string) error {
+	resp, err := r.http.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	io.Copy(io.Discard, io.LimitReader(resp.Body, 1<<16))
+	switch {
+	case resp.StatusCode >= 200 && resp.StatusCode < 300:
+		return nil
+	case req.Method == http.MethodDelete && resp.StatusCode == http.StatusNotFound:
+		return nil
+	}
+	return fmt.Errorf("%s %s: %s", req.Method, name, resp.Status)
+}

cmd/mavcaldav/render_test.go

@@ -0,0 +1,186 @@
+package main
+
+import (
+	"context"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/kami/maven/internal/ipc"
+)
+
+// reminderCore is a fakeCore that also answers ListReminders.
+type reminderCore struct {
+	fakeCore
+	reminders []ipc.Reminder
+	listErr   error
+}
+
+func (c *reminderCore) ListReminders(context.Context, int) ([]ipc.Reminder, error) {
+	if c.listErr != nil {
+		return nil, c.listErr
+	}
+	return c.reminders, nil
+}
+
+// calSrv records what a CalDAV collection received.
+type calSrv struct {
+	mu     sync.Mutex
+	puts   map[string]string
+	dels   []string
+	status int
+	*httptest.Server
+}
+
+func newCalSrv() *calSrv {
+	s := &calSrv{puts: map[string]string{}, status: http.StatusCreated}
+	s.Server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		body, _ := io.ReadAll(r.Body)
+		s.mu.Lock()
+		defer s.mu.Unlock()
+		switch r.Method {
+		case http.MethodPut:
+			s.puts[strings.TrimPrefix(r.URL.Path, "/cal/")] = string(body)
+		case http.MethodDelete:
+			s.dels = append(s.dels, strings.TrimPrefix(r.URL.Path, "/cal/"))
+		}
+		w.WriteHeader(s.status)
+	}))
+	return s
+}
+
+func (s *calSrv) putCount() int {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	return len(s.puts)
+}
+
+func TestRenderOncePublishesPendingReminders(t *testing.T) {
+	fire := time.Date(2026, 8, 1, 18, 30, 0, 0, time.UTC)
+	srv := newCalSrv()
+	defer srv.Close()
+
+	core := &reminderCore{reminders: []ipc.Reminder{
+		{ID: 7, FireTs: fire, Payload: "позвонить маме", Status: "pending"},
+		{ID: 8, FireTs: fire, Payload: "уже сделано", Status: "fired"},
+		{ID: 9, FireTs: fire, Payload: "отменено", Status: "cancelled"},
+	}}
+	r := newRenderer(core, srv.Client(), srv.URL+"/cal/", "u", "p", 0)
+	r.renderOnce(context.Background())
+
+	srv.mu.Lock()
+	body, ok := srv.puts["maven-reminder-7.ics"]
+	n := len(srv.puts)
+	srv.mu.Unlock()
+
+	if n != 1 {
+		t.Fatalf("expected exactly the pending reminder to be published, got %d PUTs", n)
+	}
+	if !ok {
+		t.Fatal("pending reminder 7 was not published")
+	}
+	if !strings.Contains(body, "SUMMARY:позвонить маме") {
+		t.Errorf("payload missing from rendered body:\n%s", body)
+	}
+	if !strings.Contains(body, "UID:maven-reminder-7") {
+		t.Errorf("UID missing from rendered body:\n%s", body)
+	}
+}
+
+func TestRenderOnceSkipsUnchanged(t *testing.T) {
+	srv := newCalSrv()
+	defer srv.Close()
+	core := &reminderCore{reminders: []ipc.Reminder{
+		{ID: 1, FireTs: time.Date(2026, 8, 1, 9, 0, 0, 0, time.UTC), Payload: "выпить воды", Status: "pending"},
+	}}
+	r := newRenderer(core, srv.Client(), srv.URL+"/cal", "u", "p", 0)
+	r.renderOnce(context.Background())
+	r.renderOnce(context.Background())
+	if got := srv.putCount(); got != 1 {
+		t.Fatalf("an unchanged reminder was re-published: %d distinct PUTs", got)
+	}
+}
+
+func TestRenderOnceWithdrawsResolvedReminders(t *testing.T) {
+	srv := newCalSrv()
+	defer srv.Close()
+	core := &reminderCore{reminders: []ipc.Reminder{
+		{ID: 5, FireTs: time.Date(2026, 8, 1, 9, 0, 0, 0, time.UTC), Payload: "встреча", Status: "pending"},
+	}}
+	r := newRenderer(core, srv.Client(), srv.URL+"/cal", "u", "p", 0)
+	r.renderOnce(context.Background())
+
+	core.reminders[0].Status = "fired"
+	r.renderOnce(context.Background())
+
+	srv.mu.Lock()
+	dels := append([]string(nil), srv.dels...)
+	srv.mu.Unlock()
+	if len(dels) != 1 || dels[0] != "maven-reminder-5.ics" {
+		t.Fatalf("resolved reminder was not withdrawn: %v", dels)
+	}
+	if len(r.published) != 0 {
+		t.Errorf("published map still holds %v", r.published)
+	}
+}
+
+// A calendar maven cannot reach must never break anything: sqlite is canonical.
+func TestRenderOnceSurvivesServerErrors(t *testing.T) {
+	srv := newCalSrv()
+	srv.status = http.StatusInternalServerError
+	defer srv.Close()
+	core := &reminderCore{reminders: []ipc.Reminder{
+		{ID: 1, FireTs: time.Date(2026, 8, 1, 9, 0, 0, 0, time.UTC), Payload: "x", Status: "pending"},
+	}}
+	r := newRenderer(core, srv.Client(), srv.URL+"/cal", "u", "p", 0)
+	r.renderOnce(context.Background())
+	if len(r.published) != 0 {
+		t.Error("a failed PUT must not be recorded as published, or it never retries")
+	}
+}
+
+func TestRenderOnceUsesNextFireForRecurring(t *testing.T) {
+	srv := newCalSrv()
+	defer srv.Close()
+	next := time.Date(2026, 8, 2, 7, 0, 0, 0, time.UTC)
+	core := &reminderCore{reminders: []ipc.Reminder{{
+		ID:         3,
+		FireTs:     time.Date(2026, 8, 1, 7, 0, 0, 0, time.UTC),
+		NextFireTs: next,
+		Payload:    "зарядка",
+		Status:     "pending",
+		Cron:       "0 7 * * *",
+	}}}
+	r := newRenderer(core, srv.Client(), srv.URL+"/cal", "u", "p", 0)
+	r.renderOnce(context.Background())
+
+	srv.mu.Lock()
+	body := srv.puts["maven-reminder-3.ics"]
+	srv.mu.Unlock()
+	if !strings.Contains(body, "DTSTART:20260802T070000Z") {
+		t.Errorf("recurring reminder should render its next occurrence:\n%s", body)
+	}
+}
+
+func TestCheckRenderTargetRefusesTheCalendarItReads(t *testing.T) {
+	read := "http://localhost:5232/kami/personal"
+	if err := checkRenderTarget(read, ""); err != nil {
+		t.Fatalf("rendering off must be fine: %v", err)
+	}
+	if err := checkRenderTarget(read, "http://localhost:5232/kami/maven"); err != nil {
+		t.Fatalf("a distinct collection must be accepted: %v", err)
+	}
+	if err := checkRenderTarget(read, read); err == nil {
+		t.Error("rendering into the read calendar must be refused")
+	}
+	if err := checkRenderTarget(read, read+"/"); err == nil {
+		t.Error("a trailing slash must not defeat the check")
+	}
+	if err := checkRenderTarget(read, strings.ToUpper(read)); err == nil {
+		t.Error("case must not defeat the check")
+	}
+}

cmd/mavend/main.go

@@ -169,6 +169,7 @@ func run(args []string) error {
 		coreAPI    ipc.CoreAPI
 		eco        *ecosystemWiring
 		factWorker *factEnrichmentWorker
+		evalWorker *memoryEvalWorker // nil ⇒ memory evaluation off (the default)
 	)
 
 	if !locked {
@@ -261,8 +262,9 @@ func run(args []string) error {
 		tickInterval := time.Duration(cfg.TickInterval)
 		repeatInterval := time.Duration(cfg.RepeatInterval)
 		autotuneInterval := time.Duration(cfg.AutotuneInterval)
-		tl = newTickLoop(st, gatherer, dispatcher, phr, rules, tickInterval, repeatInterval, autotuneInterval, cfg.Digest, routinesFromConfig(cfg.Routines), config.MorningRoutinesFromConfig(cfg.MorningRoutines))
+		tl = newTickLoop(st, gatherer, dispatcher, phr, rules, tickInterval, repeatInterval, autotuneInterval, cfg.Digest, routinesFromConfig(cfg.Routines), config.MorningRoutinesFromConfig(cfg.MorningRoutines), cfg.PatternProposals)
 		factWorker = newFactEnrichmentWorker(st, eco, time.Duration(cfg.FactEnrichmentInterval))
+		evalWorker = newMemoryEvalWorker(st, phr, cfg)
 
 		coreAPI = &daemonAPI{
 			CoreAPI:          ipc.NewStoreAPI(st),
@@ -438,8 +440,9 @@ func run(args []string) error {
 			tickInterval := time.Duration(cfg.TickInterval)
 			repeatInterval := time.Duration(cfg.RepeatInterval)
 			autotuneInterval := time.Duration(cfg.AutotuneInterval)
-			tl = newTickLoop(st, gatherer, dispatcher, phr, rules, tickInterval, repeatInterval, autotuneInterval, cfg.Digest, routinesFromConfig(cfg.Routines), config.MorningRoutinesFromConfig(cfg.MorningRoutines))
+			tl = newTickLoop(st, gatherer, dispatcher, phr, rules, tickInterval, repeatInterval, autotuneInterval, cfg.Digest, routinesFromConfig(cfg.Routines), config.MorningRoutinesFromConfig(cfg.MorningRoutines), cfg.PatternProposals)
 			factWorker = newFactEnrichmentWorker(st, eco, time.Duration(cfg.FactEnrichmentInterval))
+			evalWorker = newMemoryEvalWorker(st, phr, cfg)
 
 			// Swap the CoreAPI from the locked placeholder to the real store adapter.
 			newAPI := &daemonAPI{
@@ -476,6 +479,13 @@ func run(args []string) error {
 				factWorker.run(ctx)
 			}()
 
+			// Start background memory evaluation (nil unless configured).
+			if evalWorker != nil {
+				go func() {
+					evalWorker.run(ctx)
+				}()
+			}
+
 			dl.unlock()
 			log.Printf("mavend: unlocked via passkey assertion")
 			return nil
@@ -514,6 +524,13 @@ func run(args []string) error {
 			defer wg.Done()
 			factWorker.run(ctx)
 		}()
+		if evalWorker != nil {
+			wg.Add(1)
+			go func() {
+				defer wg.Done()
+				evalWorker.run(ctx)
+			}()
+		}
 	}
 
 	<-ctx.Done()

cmd/mavend/memoryeval.go

@@ -0,0 +1,88 @@
+// mavend/memoryeval.go — the driver for background memory evaluation
+// (Vikunja #248). The evaluator itself is pure-ish and lives in
+// internal/memeval; this is the one impure part: a ticker, the store, and the
+// resident model's base URL.
+//
+// It is its own goroutine and NOT a step on the main tick, deliberately. The
+// tick runs every 60s and has a delivery deadline behind it; an evaluation is
+// a multi-second LLM round-trip on the same llama-server that answers voice
+// turns, and it happens hourly at most. Bolting it onto the tick would make
+// every hour's tick the slow one for no benefit.
+package main
+
+import (
+	"context"
+	"log"
+	"time"
+
+	"github.com/kami/maven/internal/config"
+	"github.com/kami/maven/internal/llm"
+	"github.com/kami/maven/internal/memeval"
+	"github.com/kami/maven/internal/phraser"
+	"github.com/kami/maven/internal/store"
+)
+
+// memoryEvalWorker — ticker + evaluator.
+type memoryEvalWorker struct {
+	eval     *memeval.Evaluator
+	interval time.Duration
+}
+
+// newMemoryEvalWorker wires the evaluation loop, or returns nil when it should
+// not run at all. nil is the normal case and every caller must handle it:
+//
+//   - no memory_eval config block ⇒ off (a capability is off unless configured);
+//   - no LLM phraser ⇒ nothing to evaluate with. There is no template fallback
+//     here on purpose: a "memory evaluation" assembled from string templates
+//     would be a fixed sentence pretending to be an observation.
+func newMemoryEvalWorker(st *store.Store, phr phraser.Phraser, cfg *config.Config) *memoryEvalWorker {
+	if cfg.MemoryEval == nil {
+		return nil
+	}
+	lp, ok := phr.(*phraser.LLMPhraser)
+	if !ok {
+		log.Printf("memory eval: configured but no llama-server phraser — evaluation disabled")
+		return nil
+	}
+	interval := time.Duration(cfg.MemoryEval.Interval)
+	if interval <= 0 {
+		interval = config.DefaultMemoryEvalInterval
+	}
+	// A generous per-request timeout: this is a long prompt to a Thinking model
+	// and nobody is waiting on the answer.
+	client := llm.New(lp.BaseURL(), 5*time.Minute)
+	ev := memeval.NewEvaluator(st, st, client, memeval.Config{
+		MaxItems:      cfg.MemoryEval.MaxItems,
+		MinConfidence: cfg.MemoryEval.MinConfidence,
+		ContextBlock:  contextBlockFn(cfg, time.Now),
+	})
+	log.Printf("memory eval: enabled, every %s", interval)
+	return &memoryEvalWorker{eval: ev, interval: interval}
+}
+
+// run evaluates every interval until ctx is canceled.
+//
+// The first evaluation waits a full interval rather than firing at startup, the
+// opposite of the tick loop's cold-start behaviour. A tick that fires late is a
+// nudge that arrives late; an evaluation that fires late is nothing at all, and
+// the alternative is a heavy LLM call competing with startup — including with
+// the first voice turn after a restart.
+func (w *memoryEvalWorker) run(ctx context.Context) {
+	ticker := time.NewTicker(w.interval)
+	defer ticker.Stop()
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case now := <-ticker.C:
+			obs, err := w.eval.Evaluate(ctx, now)
+			if err != nil {
+				log.Printf("memory eval: %v", err)
+				continue
+			}
+			for _, o := range obs {
+				log.Printf("memory eval: noted (%.2f, %s): %s", o.Conf, o.Action, o.Text)
+			}
+		}
+	}
+}

cmd/mavend/patterns_test.go

@@ -3,9 +3,14 @@ package main
 import (
 	"context"
 	"database/sql"
+	"strings"
 	"testing"
 	"time"
 
+	"github.com/kami/maven/internal/config"
+	"github.com/kami/maven/internal/delivery"
+	"github.com/kami/maven/internal/loop"
+	"github.com/kami/maven/internal/pattern"
 	"github.com/kami/maven/internal/store"
 )
 
@@ -27,16 +32,16 @@ func seedRefillEvents(t *testing.T, st *store.Store, ctx context.Context, base t
 
 // TestTickDetectsPatternFromStoredEvents proves the tick notices a pattern on
 // its own, reading straight from the store — not as a side effect of a live
-// utterance (Vikunja #43). Three weekly events with no voice turn in sight
-// must produce exactly one proposed routine.
+// utterance (Vikunja #43). MinEvents weekly events with no voice turn in
+// sight must produce exactly one proposed routine.
 func TestTickDetectsPatternFromStoredEvents(t *testing.T) {
 	st := newTestStore(t)
 	ctx := context.Background()
 	now := refNow()
-	seedRefillEvents(t, st, ctx, now, 3)
+	seedRefillEvents(t, st, ctx, now, pattern.MinEvents)
 
 	tl := newTestTickLoop(t, st, &fakeSink{}, nil)
-	tl.detectPatterns(ctx, now)
+	tl.detectPatterns(ctx, now, loop.State{})
 
 	rows, err := st.ListProposedRoutines(ctx)
 	if err != nil {
@@ -58,11 +63,11 @@ func TestTickPatternDetectionIsIdempotent(t *testing.T) {
 	st := newTestStore(t)
 	ctx := context.Background()
 	now := refNow()
-	seedRefillEvents(t, st, ctx, now, 3)
+	seedRefillEvents(t, st, ctx, now, pattern.MinEvents)
 
 	tl := newTestTickLoop(t, st, &fakeSink{}, nil)
-	tl.detectPatterns(ctx, now)
-	tl.detectPatterns(ctx, now.Add(time.Hour))
+	tl.detectPatterns(ctx, now, loop.State{})
+	tl.detectPatterns(ctx, now.Add(time.Hour), loop.State{})
 
 	rows, err := st.ListProposedRoutines(ctx)
 	if err != nil {
@@ -81,10 +86,10 @@ func TestTickPatternDetectionRespectsDismissal(t *testing.T) {
 	st := newTestStore(t)
 	ctx := context.Background()
 	now := refNow()
-	seedRefillEvents(t, st, ctx, now, 3)
+	seedRefillEvents(t, st, ctx, now, pattern.MinEvents)
 
 	tl := newTestTickLoop(t, st, &fakeSink{}, nil)
-	tl.detectPatterns(ctx, now)
+	tl.detectPatterns(ctx, now, loop.State{})
 
 	rows, err := st.ListProposedRoutines(ctx)
 	if err != nil {
@@ -99,8 +104,8 @@ func TestTickPatternDetectionRespectsDismissal(t *testing.T) {
 
 	// More events for the same pair arrive, and the tick runs again — a
 	// dismissed pattern must not resurface.
-	seedRefillEvents(t, st, ctx, now.Add(30*24*time.Hour), 3)
-	tl.detectPatterns(ctx, now.Add(60*24*time.Hour))
+	seedRefillEvents(t, st, ctx, now.Add(30*24*time.Hour), pattern.MinEvents)
+	tl.detectPatterns(ctx, now.Add(60*24*time.Hour), loop.State{})
 
 	proposed, err := st.ListProposedRoutinesByStatus(ctx, store.RoutineProposed)
 	if err != nil {
@@ -120,3 +125,161 @@ func TestTickPatternDetectionRespectsDismissal(t *testing.T) {
 		t.Errorf("status = %s, want dismissed", all[0].Status)
 	}
 }
+
+// proposalRule — the rule name announceProposal uses for the seeded pair.
+const proposalRule = "proposal:refill cat_water"
+
+// TestTickProposalSilentByDefault — detection is always on, announcing is not.
+// With no pattern_proposals block the tick still records the proposal, and says
+// nothing about it: Maven is not autonomous, so a behaviour that speaks without
+// being asked stays off until it is configured.
+func TestTickProposalSilentByDefault(t *testing.T) {
+	st := newTestStore(t)
+	ctx := context.Background()
+	now := refNow()
+	seedRefillEvents(t, st, ctx, now, pattern.MinEvents)
+	markPresent(t, st, ctx, now)
+
+	sink := &fakeSink{}
+	tl := newTestTickLoop(t, st, sink, nil)
+	tl.tick(ctx, now)
+
+	if n := countSends(sink, proposalRule); n != 0 {
+		t.Fatalf("announced %d proposals with no config, want 0", n)
+	}
+	rows, err := st.ListProposedRoutinesByStatus(ctx, store.RoutineProposed)
+	if err != nil {
+		t.Fatalf("list proposed: %v", err)
+	}
+	if len(rows) != 1 {
+		t.Fatalf("proposed routines = %d, want 1 (silent, but recorded)", len(rows))
+	}
+}
+
+// TestTickAnnouncesProposalWhenConfigured — with notify on, the proposal goes
+// out once through the ordinary delivery path, worded by the detector itself.
+// Later ticks stay quiet because the pair is already proposed: one pattern is
+// one announcement, ever.
+func TestTickAnnouncesProposalWhenConfigured(t *testing.T) {
+	st := newTestStore(t)
+	ctx := context.Background()
+	now := refNow()
+	seedRefillEvents(t, st, ctx, now, pattern.MinEvents)
+	markPresent(t, st, ctx, now)
+
+	sink := &fakeSink{}
+	tl := newTestTickLoop(t, st, sink, nil)
+	tl.proposalCfg = &config.PatternProposalConfig{Notify: true}
+	tl.tick(ctx, now)
+
+	var got *delivery.Sendable
+	for i := range sink.sends {
+		if sink.sends[i].RuleName == proposalRule {
+			got = &sink.sends[i]
+		}
+	}
+	if got == nil {
+		t.Fatalf("proposal was not announced; sends=%+v", sink.sends)
+	}
+	if !strings.Contains(got.Body, "напоминать?") {
+		t.Errorf("body = %q, want the detector's own question", got.Body)
+	}
+	if got.Channel != delivery.ChannelVoice {
+		t.Errorf("channel = %v, want voice (sev1, present)", got.Channel)
+	}
+
+	// A month of further ticks: the pair already has a row, so there is
+	// nothing new to detect and nothing more to say.
+	sink.sends = nil
+	later := now.Add(40 * 24 * time.Hour)
+	markPresent(t, st, ctx, later)
+	tl.tick(ctx, later)
+	if n := countSends(sink, proposalRule); n != 0 {
+		t.Fatalf("re-announced an existing proposal %d times, want 0", n)
+	}
+}
+
+// TestTickProposalRespectsGate — a proposal is the least urgent thing Maven can
+// say, so it is sev1 and the restraint gate suppresses it. Away presence means
+// it is not announced at all: it is not held, not retried, it just lives on
+// /routines. The proposal row is still written — noticing is never gated.
+func TestTickProposalRespectsGate(t *testing.T) {
+	st := newTestStore(t)
+	ctx := context.Background()
+	now := refNow()
+	seedRefillEvents(t, st, ctx, now, pattern.MinEvents)
+	// no presence probes ⇒ away ⇒ care-class gate blocks.
+
+	sink := &fakeSink{}
+	tl := newTestTickLoop(t, st, sink, nil)
+	tl.proposalCfg = &config.PatternProposalConfig{Notify: true}
+	tl.tick(ctx, now)
+
+	if n := countSends(sink, proposalRule); n != 0 {
+		t.Fatalf("away: announced %d proposals, want 0", n)
+	}
+	if !tl.lastProposalAt.IsZero() {
+		t.Error("cooldown clock advanced on a suppressed announcement")
+	}
+	rows, err := st.ListProposedRoutinesByStatus(ctx, store.RoutineProposed)
+	if err != nil {
+		t.Fatalf("list proposed: %v", err)
+	}
+	if len(rows) != 1 {
+		t.Fatalf("proposed routines = %d, want 1 (detection is never gated)", len(rows))
+	}
+}
+
+// TestTickProposalCooldownSpacesAnnouncements — two patterns detected on the
+// same tick must not become two interruptions. The second one waits for the
+// cooldown, and is on /routines meanwhile.
+func TestTickProposalCooldownSpacesAnnouncements(t *testing.T) {
+	st := newTestStore(t)
+	ctx := context.Background()
+	now := refNow()
+	seedRefillEvents(t, st, ctx, now, pattern.MinEvents)
+	for i := 0; i < pattern.MinEvents; i++ {
+		ts := now.Add(time.Duration(i) * 3 * 24 * time.Hour)
+		factID, err := st.WriteFact(ctx, ts, store.KindSelf, "litter_box", "clean", "test", 1.0, sql.NullInt64{})
+		if err != nil {
+			t.Fatalf("write fact: %v", err)
+		}
+		if _, err := st.CreateEvent(ctx, factID, "clean", "litter_box", ts); err != nil {
+			t.Fatalf("create event: %v", err)
+		}
+	}
+	markPresent(t, st, ctx, now)
+
+	sink := &fakeSink{}
+	tl := newTestTickLoop(t, st, sink, nil)
+	tl.proposalCfg = &config.PatternProposalConfig{Notify: true, Cooldown: config.Duration(24 * time.Hour)}
+	tl.tick(ctx, now)
+
+	announced := 0
+	for _, s := range sink.sends {
+		if strings.HasPrefix(s.RuleName, "proposal:") {
+			announced++
+		}
+	}
+	if announced != 1 {
+		t.Fatalf("announced %d proposals on one tick, want exactly 1", announced)
+	}
+	rows, err := st.ListProposedRoutinesByStatus(ctx, store.RoutineProposed)
+	if err != nil {
+		t.Fatalf("list proposed: %v", err)
+	}
+	if len(rows) != 2 {
+		t.Fatalf("proposed routines = %d, want 2 (both recorded, one announced)", len(rows))
+	}
+
+	// Still inside the cooldown: silence, even though a proposal is pending.
+	sink.sends = nil
+	soon := now.Add(time.Hour)
+	markPresent(t, st, ctx, soon)
+	tl.tick(ctx, soon)
+	for _, s := range sink.sends {
+		if strings.HasPrefix(s.RuleName, "proposal:") {
+			t.Fatalf("announced %q inside the cooldown", s.RuleName)
+		}
+	}
+}

cmd/mavend/tick.go

@@ -24,6 +24,7 @@ import (
 	"github.com/kami/maven/internal/ipc"
 	"github.com/kami/maven/internal/loop"
 	"github.com/kami/maven/internal/morning"
+	"github.com/kami/maven/internal/pattern"
 	"github.com/kami/maven/internal/phraser"
 	"github.com/kami/maven/internal/routine"
 	"github.com/kami/maven/internal/store"
@@ -67,6 +68,14 @@ type tickLoop struct {
 	morningRoutines []morning.Routine
 	morningLast     map[string]time.Time
 
+	// proposalCfg — announcement policy for routines the tick inferred itself.
+	// nil ⇒ detect silently, never announce (the default). lastProposalAt is
+	// the cooldown clock, in-memory on purpose: a restart is allowed to permit
+	// one more announcement, and a restart-per-day loop is a bigger problem
+	// than a duplicate proposal notice.
+	proposalCfg    *config.PatternProposalConfig
+	lastProposalAt time.Time
+
 	// digestQ — in-memory queue of eligible nudges waiting for batch flush.
 	// populated when digestCfg != nil && digestCfg.Enabled.
 	digestQ []QueuedNudge
@@ -92,6 +101,7 @@ func newTickLoop(
 	digestCfg *config.DigestConfig,
 	routines []routine.Routine,
 	morningRoutines []morning.Routine,
+	proposalCfg *config.PatternProposalConfig,
 ) *tickLoop {
 	return &tickLoop{
 		store:            st,
@@ -108,6 +118,7 @@ func newTickLoop(
 		routineLast:      make(map[string]time.Time),
 		morningRoutines:  morningRoutines,
 		morningLast:      make(map[string]time.Time),
+		proposalCfg:      proposalCfg,
 		lastPhrase:       make(map[string]delivery.PhrasedNudge),
 	}
 }
@@ -212,7 +223,7 @@ func (t *tickLoop) tick(ctx context.Context, now time.Time) {
 	// path, so a pattern already sitting in history went unnoticed until he
 	// happened to mention it again by voice. See patterns.go and
 	// detectPatterns below for how idempotence and dismissal are respected.
-	t.detectPatterns(ctx, now)
+	t.detectPatterns(ctx, now, state)
 
 	// reminders: gate-bypassing class. fired once, marked after a successful
 	// delivery.  a failed send leaves the reminder pending — the next tick
@@ -381,16 +392,19 @@ func (t *tickLoop) flushDigest(ctx context.Context, now time.Time, state loop.St
 //     resurrecting — there is nothing tick-specific to get right here beyond
 //     calling the same shared path the voice route already used.
 //
-// This only ever creates a row for the /routines page to show. It does not
-// notify, ring, or speak — Maven is "not a nag, not autonomous" (CLAUDE.md),
-// and detection is not the same act as disturbing him about it. A proposal
-// only starts producing nudges once he accepts it (fireAcceptedRoutines).
-func (t *tickLoop) detectPatterns(ctx context.Context, now time.Time) {
+// By default this only creates a row for the /routines page to show: it does
+// not notify, ring, or speak. Detection is not the same act as disturbing him
+// about it, and Maven is "not a nag, not autonomous" (CLAUDE.md). Announcing
+// is opt-in through the pattern_proposals config block — see announceProposal
+// for the restraints that apply even then. A proposal only starts producing
+// recurring nudges once he accepts it (fireAcceptedRoutines).
+func (t *tickLoop) detectPatterns(ctx context.Context, now time.Time, state loop.State) {
 	pairs, err := t.store.DistinctEventPairs(ctx)
 	if err != nil {
 		log.Printf("tick: distinct event pairs: %v", err)
 		return
 	}
+	announced := false
 	for _, p := range pairs {
 		r, _, err := detectAndPropose(ctx, t.store, p.Action, p.Object, now)
 		if err != nil {
@@ -401,9 +415,65 @@ func (t *tickLoop) detectPatterns(ctx context.Context, now time.Time) {
 			continue // no stable pattern, or already proposed/accepted/dismissed
 		}
 		log.Printf("tick: proposed routine: %s/%s every %.1f days", r.Action, r.Object, r.IntervalDays)
+		// One announcement per tick at most, whatever the scan turned up. The
+		// rest are on /routines; they are not lost, they are just not shouted.
+		if announced {
+			continue
+		}
+		announced = t.announceProposal(ctx, r, now, state)
 	}
 }
 
+// announceProposal offers a freshly inferred routine through the ordinary
+// care-delivery path, if announcing is switched on at all. Returns true when
+// something was actually sent.
+//
+// Everything here is restraint. The feature is off unless configured; when on
+// it is sev1 (the lowest severity, so quiet hours, away presence and snooze
+// all suppress it via loop.Gate exactly like a care nudge); it is spaced by
+// proposalCfg.Cooldown across every pair, not per pair; and a suppressed or
+// dropped announcement is NOT retried — the cooldown clock advances only on a
+// real send, but the proposal row already exists, so the next tick will not
+// re-detect it and nothing queues up behind it. A missed announcement means
+// he reads it on /routines instead, which is the whole point of the page.
+//
+// The body is the detector's own literal Russian phrasing (pattern.PhraseRoutine
+// — "ты заправляешь поилку раз в 7 дней — напоминать?"), not LLM-generated, so
+// an inferred routine cannot arrive worded as something Maven never observed.
+func (t *tickLoop) announceProposal(ctx context.Context, r *pattern.ProposedRoutine, now time.Time, state loop.State) bool {
+	if !t.proposalCfg.AnnounceProposals() {
+		return false
+	}
+	cooldown := time.Duration(t.proposalCfg.Cooldown)
+	if cooldown <= 0 {
+		cooldown = config.DefaultProposalCooldown
+	}
+	if !t.lastProposalAt.IsZero() && now.Sub(t.lastProposalAt) < cooldown {
+		return false
+	}
+
+	rule := loop.Rule{Name: "proposal:" + r.Action + " " + r.Object, Severity: loop.Sev1}
+	if !loop.Gate(state, rule) {
+		return false
+	}
+	body := pattern.PhraseRoutine(r)
+	pn := delivery.PhrasedNudge{
+		Candidate: loop.Candidate{Rule: rule, Severity: rule.Severity, State: state},
+		Body:      body,
+		Summary:   body,
+	}
+	sent, err := t.dispatcher.DispatchNudge(ctx, pn, now)
+	if err != nil {
+		log.Printf("tick: announce proposal %s/%s: %v", r.Action, r.Object, err)
+		return false
+	}
+	if len(sent) == 0 {
+		return false // routing dropped it — /routines still has it.
+	}
+	t.lastProposalAt = now
+	return true
+}
+
 // digestExpiry — how long a gate-suppressed care nudge stays worth
 // resurfacing. 24h: these are daily-cadence rules (water/meal/break run on
 // hour-scale cooldowns and re-derive from facts that reset every day), so a

cmd/mavend/tick_test.go

@@ -46,7 +46,7 @@ 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, nil, nil)
+	return newTickLoop(st, g, d, phraser.NewStub(), rules, time.Second, 5*time.Minute, 0, digestCfg, nil, nil, nil)
 }
 
 func TestTickFiresRoutineWhenScheduleCrosses(t *testing.T) {
@@ -63,7 +63,7 @@ func TestTickFiresRoutineWhenScheduleCrosses(t *testing.T) {
 	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, nil)
+	tl := newTickLoop(st, g, d, phraser.NewStub(), rules, time.Second, 5*time.Minute, 0, nil, rs, nil, nil)
 
 	// first tick: seeds, does not fire the routine.
 	tl.tick(ctx, now)

deploy/mavend.json

@@ -26,6 +26,11 @@
     "severity_ceiling": 2
   },
 
+  "pattern_proposals": {
+    "notify": false,
+    "cooldown": "24h"
+  },
+
   "nexus":  { "url": "http://nexus:9740" },
   "praxis": { "url": "http://praxis:8989" },
   "hexis":  { "url": "http://hexis:9741" },

docs/plans/03-memory-evaluation.md

@@ -25,3 +25,46 @@
 6. Add `/eval` API method to `ipc.CoreAPI` (or reuse `Chat` with system context) so mavweb can show evaluation history
 7. Add `memory_eval` block to `deploy/mavend.json`
 8. Test with synthetic store state — verify observations match expected patterns
+
+---
+
+## Status 2026-08-01 — foundation shipped (Vikunja #248)
+
+**Shipped:** `internal/memeval` (not `internal/memory/eval.go` — `internal/store`
+imports `internal/memory` for the vector backend, so an evaluator that reads
+`store.Fact` there would close an import cycle). `Evaluator.Evaluate` reads
+`RecentFacts` / `RecentNotes` / `RecentNudges`, prompts the resident model under
+a GBNF grammar for at most three `{observation, confidence, suggested_action}`
+objects, drops anything under `min_confidence`, deduplicates against what earlier
+evaluations wrote, and records the rest as notes with source `infer:memory-eval`.
+Driver: `cmd/mavend/memoryeval.go`, its own goroutine on its own ticker. Config:
+the `memory_eval` block — **absent ⇒ the loop does not run**. Visibility: `/dash`
+already renders notes with their source, so evaluation output is visible with no
+UI change.
+
+**Deliberately not shipped — this is policy, not an unfinished edge:**
+
+- *Dispatching observations as care nudges (plan step 4).* An hourly LLM loop
+  with permission to speak is a machine for generating interruptions, and the
+  content is model-generated text about his own life. The evaluator has no
+  dispatcher reference at all, so it cannot reach a channel by accident. Wiring
+  it to `delivery.Dispatcher` is a separate decision with its own opt-in.
+- *Acting on `suggested_action`.* It is recorded inside the note text and
+  interpreted by nobody. No reminder, routine or fact is created.
+- *Writing observation embeddings.* Notes are written with a nil embedding, so
+  they stay out of the RAG recall pool. Feeding generated text back into the pool
+  it came from is how a small model starts citing its own guesses as evidence.
+
+**Deferred, wants a decision or another capability:**
+
+- *Plan step 6, the `/eval` IPC method and an evaluation-history view.* `/dash`
+  covers reading the output; a dedicated trace surface is worth building once
+  there is real output to look at, and it should probably show the prompt too.
+- *`RecentEvents`.* The plan lists it; the evaluator reads facts, notes and
+  nudges. Detected action/object events already drive pattern proposals (#43), and
+  duplicating them here would mostly re-derive that.
+- *Output quality is unmeasured.* There is no fixture for "did she notice
+  something true". The tests cover the machinery — empty store, confidence floor,
+  dedupe, own-notes exclusion, error handling — not the observations. Until
+  someone reads a week of real output on `/dash`, treat the wording and the
+  `min_confidence` default as unvalidated.

internal/calendar/calendar.go

@@ -0,0 +1,129 @@
+// Package calendar is the one calendar data model the rest of maven shares:
+// an Event, the iCal text it is parsed from and rendered to, and the fact
+// encoding that puts it in the store.
+//
+// It exists because three separate features read or write the same events and
+// must agree on their shape: the CalDAV read side (cmd/mavcaldav, Vikunja
+// #126/#127), the write-only render target that publishes maven's own
+// reminders as a calendar (#127), and the day plan that recites them (#128).
+// Before this package the parse lived inline in cmd/mavcaldav and the fact key
+// format was a Sprintf in two places.
+//
+// The package is pure: no HTTP, no store, no clock of its own. Callers own the
+// impurity, the way internal/morning and internal/loop do.
+package calendar
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+	"time"
+)
+
+// Fact sources. A calendar event reaches the store as a
+// `facts (kind=env, key=calendar_event_..., source=<one of these>)` row, and
+// the source is the whole provenance story:
+//
+//   - SourcePersonal — maven's own Radicale, read AND rendered to. Canonical
+//     state stays in sqlite; the calendar is a render target (#127).
+//   - SourceWork — a work calendar, read-only by definition (#126). Nothing in
+//     maven ever writes to it: no code path pairs this source with a PUT.
+//   - SourceAmbient — inferred from an Android notification-listener relay
+//     rather than read from a server (#126). Confidence is below 1.0 because a
+//     notification is a signal about an event, not the event.
+const (
+	SourcePersonal = "poll:caldav"
+	SourceWork     = "poll:caldav:work"
+	SourceAmbient  = "ambient:notif"
+)
+
+// AmbientConfidence — the confidence a notification-derived event is stored
+// with. A parsed notification line is evidence, not a reading of the calendar,
+// so it must never be indistinguishable from one (#126).
+const AmbientConfidence = 0.6
+
+// Sources lists every source a calendar event may legitimately carry, for the
+// store query that reads the calendar back out. Ordered from most to least
+// trusted.
+func Sources() []string {
+	return []string{SourcePersonal, SourceWork, SourceAmbient}
+}
+
+// ReadOnlySource reports whether events from this source may never be written
+// back. The work calendar is read-only by definition — see #126: maven holding
+// a credential that can write to an employer's calendar is the thing the task
+// exists to avoid.
+func ReadOnlySource(source string) bool {
+	return source == SourceWork || source == SourceAmbient
+}
+
+// Event — one calendar entry. UID is the iCal UID when the event was parsed
+// from a server and the identity maven renders under when it publishes one;
+// Start/End are instants. All-day events are not modelled: the busy gate and
+// the day plan both need a time of day, and an all-day marker answers neither.
+type Event struct {
+	UID     string
+	Summary string
+	Start   time.Time
+	End     time.Time
+}
+
+// FactKey is the store key for an event: one key per day per summary, stable
+// across polls so re-reading an unchanged calendar rewrites nothing.
+//
+// The date prefix is load-bearing — store.CalendarEvents selects a day range
+// by key prefix, not by a timestamp column.
+func FactKey(e Event) string {
+	return fmt.Sprintf("calendar_event_%s_%s", e.Start.Format("20060102"), safeKey(e.Summary))
+}
+
+// FactValue is the human-readable rendering stored as the fact value, and the
+// string the day plan and the query path read back.
+func FactValue(e Event) string {
+	return fmt.Sprintf("%s @ %s-%s", e.Summary, e.Start.Format("15:04"), e.End.Format("15:04"))
+}
+
+// KeyPrefixForDay is the fact-key prefix covering one calendar day. The store
+// range-scans between two of these.
+func KeyPrefixForDay(day time.Time) string {
+	return fmt.Sprintf("calendar_event_%s", day.Format("20060102"))
+}
+
+// Busy reports whether any event covers the instant now — the read the loop
+// gate uses to suppress nudges during a meeting.
+func Busy(events []Event, now time.Time) bool {
+	for _, e := range events {
+		if !now.Before(e.Start) && now.Before(e.End) {
+			return true
+		}
+	}
+	return false
+}
+
+// Overlapping returns the events intersecting [from, to), sorted by start.
+func Overlapping(events []Event, from, to time.Time) []Event {
+	var out []Event
+	for _, e := range events {
+		if e.End.After(from) && e.Start.Before(to) {
+			out = append(out, e)
+		}
+	}
+	sort.Slice(out, func(i, j int) bool { return out[i].Start.Before(out[j].Start) })
+	return out
+}
+
+// safeKey makes a summary safe to use inside a fact key (ASCII alphanumerics
+// and dashes). Non-Latin summaries collapse to their punctuation, which is why
+// the day prefix carries the identity and this only disambiguates within a day.
+func safeKey(s string) string {
+	var b strings.Builder
+	for _, r := range s {
+		switch {
+		case (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') || (r >= '0' && r <= '9') || r == '-':
+			b.WriteRune(r)
+		case r == ' ' || r == '_':
+			b.WriteRune('-')
+		}
+	}
+	return b.String()
+}

internal/calendar/calendar_test.go

@@ -0,0 +1,202 @@
+package calendar
+
+import (
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestParseICalDayKeepsOnlyToday(t *testing.T) {
+	now := time.Date(2026, 7, 3, 12, 0, 0, 0, time.UTC)
+
+	body := []byte(`BEGIN:VCALENDAR
+BEGIN:VEVENT
+UID:a@example
+DTSTART:20260703T090000Z
+DTEND:20260703T100000Z
+SUMMARY:Morning standup
+END:VEVENT
+BEGIN:VEVENT
+DTSTART:20260703T140000Z
+DTEND:20260703T150000Z
+SUMMARY:Team sync
+END:VEVENT
+BEGIN:VEVENT
+DTSTART:20260702T140000Z
+DTEND:20260702T150000Z
+SUMMARY:Yesterday retro
+END:VEVENT
+BEGIN:VEVENT
+DTSTART:20260704T090000Z
+DTEND:20260704T100000Z
+SUMMARY:Tomorrow standup
+END:VEVENT
+BEGIN:VEVENT
+DTSTART;VALUE=DATE:20260704
+DTEND;VALUE=DATE:20260705
+SUMMARY:All-day event
+END:VEVENT
+END:VCALENDAR`)
+
+	events := ParseICalDay(body, now)
+	if len(events) != 2 {
+		t.Fatalf("got %d events, want 2 (today only, no all-day/past/future)", len(events))
+	}
+	if events[0].Summary != "Morning standup" || events[0].UID != "a@example" {
+		t.Errorf("events[0] = %+v", events[0])
+	}
+	if !events[0].Start.Equal(time.Date(2026, 7, 3, 9, 0, 0, 0, time.UTC)) {
+		t.Errorf("events[0].Start = %v", events[0].Start)
+	}
+	if !events[0].End.Equal(time.Date(2026, 7, 3, 10, 0, 0, 0, time.UTC)) {
+		t.Errorf("events[0].End = %v", events[0].End)
+	}
+	if events[1].Summary != "Team sync" {
+		t.Errorf("events[1].Summary = %q", events[1].Summary)
+	}
+}
+
+// Regression: "today" is the owner's day, in the owner's location. Taking the
+// day number off a local clock but building the boundaries in UTC made the
+// evening fall outside the window on any box east of Greenwich.
+func TestParseICalDayUsesOwnersDay(t *testing.T) {
+	plus4 := time.FixedZone("+04", 4*60*60)
+	// 01:00 on Aug 1 local is 21:00 on Jul 31 UTC.
+	now := time.Date(2026, 8, 1, 1, 0, 0, 0, plus4)
+	body := []byte("BEGIN:VCALENDAR\nBEGIN:VEVENT\n" +
+		"DTSTART:20260731T195406Z\nDTEND:20260731T235406Z\nSUMMARY:Current meeting\n" +
+		"END:VEVENT\nEND:VCALENDAR")
+
+	events := ParseICalDay(body, now)
+	if len(events) != 1 {
+		t.Fatalf("got %d events, want the in-progress one", len(events))
+	}
+	if !Busy(events, now.UTC()) {
+		t.Error("an event in progress right now must read as busy")
+	}
+}
+
+func TestParseVEVENT(t *testing.T) {
+	block := "DTSTART;TZID=Europe/Moscow:20260703T130000\nDTEND:20260703T140000Z\nSUMMARY:Stand up meeting"
+	e, ok := parseVEVENT(block)
+	if !ok {
+		t.Fatal("expected a parsed event")
+	}
+	if !e.Start.Equal(time.Date(2026, 7, 3, 13, 0, 0, 0, time.UTC)) {
+		t.Errorf("start = %v", e.Start)
+	}
+	if !e.End.Equal(time.Date(2026, 7, 3, 14, 0, 0, 0, time.UTC)) {
+		t.Errorf("end = %v", e.End)
+	}
+	if e.Summary != "Stand up meeting" {
+		t.Errorf("summary = %q", e.Summary)
+	}
+
+	allDay := "DTSTART;VALUE=DATE:20260703\nDTEND;VALUE=DATE:20260704\nSUMMARY:All-day"
+	if _, ok := parseVEVENT(allDay); ok {
+		t.Error("all-day event should be rejected")
+	}
+}
+
+func TestParseDT(t *testing.T) {
+	tests := []struct {
+		name   string
+		line   string
+		want   time.Time
+		wantOK bool
+	}{
+		{"UTC", "DTEND:20260703T100000Z", time.Date(2026, 7, 3, 10, 0, 0, 0, time.UTC), true},
+		{"local", "DTSTART;TZID=Europe/Moscow:20260703T130000", time.Date(2026, 7, 3, 13, 0, 0, 0, time.UTC), true},
+		{"all-day", "DTSTART;VALUE=DATE:20260703", time.Time{}, false},
+		{"garbage", "DTSTART:garbage", time.Time{}, false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, ok := parseDT(tt.line)
+			if ok != tt.wantOK {
+				t.Errorf("ok = %v, want %v", ok, tt.wantOK)
+			}
+			if !got.Equal(tt.want) {
+				t.Errorf("got %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestSafeKey(t *testing.T) {
+	tests := []struct{ in, want string }{
+		{"Stand up meeting", "Stand-up-meeting"},
+		{"Hello_World", "Hello-World"},
+		{"special@#$chars!!", "specialchars"},
+		{"ALL_CAPS_123", "ALL-CAPS-123"},
+	}
+	for _, tt := range tests {
+		if got := safeKey(tt.in); got != tt.want {
+			t.Errorf("safeKey(%q) = %q, want %q", tt.in, got, tt.want)
+		}
+	}
+}
+
+func TestFactKeyAndValue(t *testing.T) {
+	e := Event{
+		Summary: "Team sync",
+		Start:   time.Date(2026, 7, 3, 14, 0, 0, 0, time.UTC),
+		End:     time.Date(2026, 7, 3, 15, 0, 0, 0, time.UTC),
+	}
+	if got, want := FactKey(e), "calendar_event_20260703_Team-sync"; got != want {
+		t.Errorf("FactKey = %q, want %q", got, want)
+	}
+	if got, want := FactValue(e), "Team sync @ 14:00-15:00"; got != want {
+		t.Errorf("FactValue = %q, want %q", got, want)
+	}
+	if got, want := KeyPrefixForDay(e.Start), "calendar_event_20260703"; got != want {
+		t.Errorf("KeyPrefixForDay = %q, want %q", got, want)
+	}
+	if !strings.HasPrefix(FactKey(e), KeyPrefixForDay(e.Start)) {
+		t.Error("FactKey must start with the day prefix the store range-scans on")
+	}
+}
+
+func TestBusyAndOverlapping(t *testing.T) {
+	base := time.Date(2026, 7, 3, 0, 0, 0, 0, time.UTC)
+	events := []Event{
+		{Summary: "late", Start: base.Add(15 * time.Hour), End: base.Add(16 * time.Hour)},
+		{Summary: "early", Start: base.Add(9 * time.Hour), End: base.Add(10 * time.Hour)},
+	}
+	if !Busy(events, base.Add(9*time.Hour+30*time.Minute)) {
+		t.Error("should be busy inside the early event")
+	}
+	if Busy(events, base.Add(12*time.Hour)) {
+		t.Error("should be free at noon")
+	}
+	// Half-open: the end instant is free.
+	if Busy(events, base.Add(10*time.Hour)) {
+		t.Error("the end instant should not count as busy")
+	}
+	got := Overlapping(events, base.Add(8*time.Hour), base.Add(11*time.Hour))
+	if len(got) != 1 || got[0].Summary != "early" {
+		t.Fatalf("Overlapping = %+v", got)
+	}
+	all := Overlapping(events, base, base.AddDate(0, 0, 1))
+	if len(all) != 2 || all[0].Summary != "early" {
+		t.Fatalf("Overlapping must sort by start: %+v", all)
+	}
+}
+
+func TestSourceTrust(t *testing.T) {
+	if ReadOnlySource(SourcePersonal) {
+		t.Error("the personal calendar is the one maven may render to")
+	}
+	if !ReadOnlySource(SourceWork) {
+		t.Error("the work calendar must be read-only")
+	}
+	if !ReadOnlySource(SourceAmbient) {
+		t.Error("an ambient notification is not a writable calendar")
+	}
+	if AmbientConfidence >= 1.0 {
+		t.Error("ambient events must be less trusted than a calendar read")
+	}
+	if len(Sources()) != 3 {
+		t.Errorf("Sources() = %v", Sources())
+	}
+}

internal/calendar/ical.go

@@ -0,0 +1,145 @@
+package calendar
+
+import (
+	"fmt"
+	"strings"
+	"time"
+)
+
+// ParseICal scans iCal text for VEVENT components and returns the events
+// overlapping [from, to). All-day events are skipped: parseDT reports no time
+// for a VALUE=DATE value, and an event with no clock reading answers neither
+// the busy gate nor the day plan.
+func ParseICal(body []byte, from, to time.Time) []Event {
+	var events []Event
+	text := string(body)
+	for {
+		i := strings.Index(text, "BEGIN:VEVENT")
+		if i < 0 {
+			break
+		}
+		text = text[i+len("BEGIN:VEVENT"):]
+		j := strings.Index(text, "END:VEVENT")
+		if j < 0 {
+			break
+		}
+		block := text[:j]
+		text = text[j+len("END:VEVENT"):]
+
+		e, ok := parseVEVENT(block)
+		if !ok {
+			continue
+		}
+		if e.End.After(from) && e.Start.Before(to) {
+			events = append(events, e)
+		}
+	}
+	return events
+}
+
+// ParseICalDay is ParseICal over the calendar day containing now, in now's own
+// location — the window cmd/mavcaldav polls.
+//
+// The location matters. The old inline version took the day number off a local
+// clock reading but built the boundaries in UTC, so east of Greenwich the
+// window was shifted by the offset and part of the evening fell outside
+// "today": on a +04 box after 20:00 UTC the poller saw an empty calendar. The
+// owner's day is the day the day plan and the busy gate mean.
+func ParseICalDay(body []byte, now time.Time) []Event {
+	y, m, d := now.Date()
+	start := time.Date(y, m, d, 0, 0, 0, 0, now.Location())
+	return ParseICal(body, start, start.AddDate(0, 0, 1))
+}
+
+// parseVEVENT extracts UID, start, end and summary from a VEVENT block.
+// Reports false for all-day events and parse failures.
+func parseVEVENT(block string) (Event, bool) {
+	var e Event
+	for _, line := range strings.Split(block, "\n") {
+		line = strings.TrimSpace(line)
+		switch {
+		case strings.HasPrefix(line, "DTSTART"):
+			if t, ok := parseDT(line); ok {
+				e.Start = t
+			}
+		case strings.HasPrefix(line, "DTEND"):
+			if t, ok := parseDT(line); ok {
+				e.End = t
+			}
+		case strings.HasPrefix(line, "SUMMARY"):
+			e.Summary = afterColon(line)
+		case strings.HasPrefix(line, "UID"):
+			e.UID = afterColon(line)
+		}
+	}
+	if e.Start.IsZero() || e.End.IsZero() {
+		return Event{}, false
+	}
+	return e, true
+}
+
+func afterColon(line string) string {
+	if i := strings.Index(line, ":"); i >= 0 {
+		return strings.TrimSpace(line[i+1:])
+	}
+	return ""
+}
+
+// parseDT parses a DTSTART/DTEND value:
+//
+//   - UTC:      DTEND:20260703T100000Z
+//   - Local:    DTSTART;TZID=Europe/Moscow:20260703T130000
+//   - All-day:  DTSTART;VALUE=DATE:20260703  (rejected)
+//
+// A local time is read as UTC, the behaviour cmd/mavcaldav has always had: the
+// CalDAV server and the poller run in the same timezone, and the busy gate only
+// needs busy/not-busy to be right.
+func parseDT(line string) (time.Time, bool) {
+	if strings.Contains(line, "VALUE=DATE:") {
+		return time.Time{}, false
+	}
+	i := strings.LastIndex(line, ":")
+	if i < 0 {
+		return time.Time{}, false
+	}
+	val := strings.TrimSuffix(strings.TrimSpace(line[i+1:]), "Z")
+	t, err := time.Parse("20060102T150405", val)
+	if err != nil {
+		return time.Time{}, false
+	}
+	return t.UTC(), true
+}
+
+// RenderICal wraps events in a VCALENDAR body suitable for PUTting to a CalDAV
+// collection. One event per file is the CalDAV convention, so callers normally
+// pass a single event.
+//
+// This is the write half of #127 and it only ever renders: the canonical state
+// is sqlite, the calendar is a view of it. Nothing reads a rendered file back.
+func RenderICal(events []Event) string {
+	var b strings.Builder
+	b.WriteString("BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:-//maven//local calendar//RU\r\n")
+	for _, e := range events {
+		b.WriteString("BEGIN:VEVENT\r\n")
+		fmt.Fprintf(&b, "UID:%s\r\n", escapeText(e.UID))
+		fmt.Fprintf(&b, "DTSTAMP:%s\r\n", e.Start.UTC().Format("20060102T150405Z"))
+		fmt.Fprintf(&b, "DTSTART:%s\r\n", e.Start.UTC().Format("20060102T150405Z"))
+		fmt.Fprintf(&b, "DTEND:%s\r\n", e.End.UTC().Format("20060102T150405Z"))
+		fmt.Fprintf(&b, "SUMMARY:%s\r\n", escapeText(e.Summary))
+		b.WriteString("END:VEVENT\r\n")
+	}
+	b.WriteString("END:VCALENDAR\r\n")
+	return b.String()
+}
+
+// escapeText applies RFC 5545 TEXT escaping and strips the line breaks that
+// would otherwise let a reminder payload inject iCal properties.
+func escapeText(s string) string {
+	s = strings.ReplaceAll(s, "\\", "\\\\")
+	s = strings.ReplaceAll(s, ";", "\\;")
+	s = strings.ReplaceAll(s, ",", "\\,")
+	s = strings.ReplaceAll(s, "\r\n", "\\n")
+	s = strings.ReplaceAll(s, "\n", "\\n")
+	s = strings.ReplaceAll(s, "\r", "\\n")
+	return s
+}

internal/calendar/ical_render_test.go

@@ -0,0 +1,69 @@
+package calendar
+
+import (
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestRenderICalRoundTrips(t *testing.T) {
+	e := ReminderEvent(7, time.Date(2026, 8, 1, 18, 30, 0, 0, time.UTC), "позвонить маме", 0)
+	if e.UID != "maven-reminder-7" {
+		t.Errorf("UID = %q", e.UID)
+	}
+	if got := e.End.Sub(e.Start); got != DefaultReminderDuration {
+		t.Errorf("duration = %v, want %v", got, DefaultReminderDuration)
+	}
+	if got, want := ReminderPath(7), "maven-reminder-7.ics"; got != want {
+		t.Errorf("ReminderPath = %q, want %q", got, want)
+	}
+
+	body := RenderICal([]Event{e})
+	if !strings.HasPrefix(body, "BEGIN:VCALENDAR\r\n") || !strings.HasSuffix(body, "END:VCALENDAR\r\n") {
+		t.Fatalf("not a VCALENDAR body:\n%s", body)
+	}
+
+	back := ParseICal([]byte(body), e.Start.Add(-time.Hour), e.Start.Add(time.Hour))
+	if len(back) != 1 {
+		t.Fatalf("got %d events back, want 1:\n%s", len(back), body)
+	}
+	if back[0].UID != e.UID || back[0].Summary != e.Summary {
+		t.Errorf("round trip lost identity: %+v", back[0])
+	}
+	if !back[0].Start.Equal(e.Start) || !back[0].End.Equal(e.End) {
+		t.Errorf("round trip lost times: %+v", back[0])
+	}
+}
+
+func TestRenderICalIsDeterministic(t *testing.T) {
+	e := ReminderEvent(1, time.Date(2026, 8, 1, 9, 0, 0, 0, time.UTC), "выпить воды", 0)
+	if RenderICal([]Event{e}) != RenderICal([]Event{e}) {
+		t.Error("the same reminder must render byte-identically, or every poll re-PUTs it")
+	}
+}
+
+// A reminder payload is owner-supplied text. It must not be able to close the
+// VEVENT and inject properties of its own.
+func TestRenderICalEscapesInjection(t *testing.T) {
+	e := ReminderEvent(2, time.Date(2026, 8, 1, 9, 0, 0, 0, time.UTC),
+		"обед\r\nEND:VEVENT\r\nBEGIN:VEVENT\r\nSUMMARY:injected", 0)
+	body := RenderICal([]Event{e})
+	// Count line-initial occurrences: the escaped text still contains the
+	// characters "BEGIN:VEVENT", it just can no longer start a line.
+	if n := strings.Count(body, "\r\nBEGIN:VEVENT\r\n"); n != 1 {
+		t.Fatalf("payload injected a second VEVENT (%d):\n%s", n, body)
+	}
+	if n := strings.Count(body, "\r\nEND:VEVENT\r\n"); n != 1 {
+		t.Fatalf("payload closed the VEVENT early (%d):\n%s", n, body)
+	}
+	if !strings.Contains(body, `SUMMARY:обед\nEND:VEVENT`) {
+		t.Errorf("newlines should be escaped, not dropped:\n%s", body)
+	}
+}
+
+func TestReminderEventEmptyPayload(t *testing.T) {
+	e := ReminderEvent(3, time.Date(2026, 8, 1, 9, 0, 0, 0, time.UTC), "   ", 0)
+	if e.Summary != "напоминание" {
+		t.Errorf("Summary = %q, want the neutral RU fallback", e.Summary)
+	}
+}

internal/calendar/reminder.go

@@ -0,0 +1,45 @@
+package calendar
+
+import (
+	"fmt"
+	"strings"
+	"time"
+)
+
+// ReminderUIDPrefix namespaces every event maven publishes. Two reasons it is a
+// fixed prefix and not a random UUID: the render is idempotent (the same
+// reminder always lands on the same UID, so re-rendering overwrites instead of
+// duplicating), and everything maven owns in the target collection is
+// identifiable at a glance — she never touches a file she did not create.
+const ReminderUIDPrefix = "maven-reminder-"
+
+// DefaultReminderDuration — how long a rendered reminder occupies. A reminder
+// is an instant, a calendar entry is a span, so one has to be invented; 30
+// minutes reads as a block in a calendar app without swallowing the afternoon.
+const DefaultReminderDuration = 30 * time.Minute
+
+// ReminderEvent maps a reminder to the event that represents it. id and fire
+// come from the store; payload is the RU text as the owner said it, rendered
+// verbatim as the summary — the calendar is a view of sqlite, not a place to
+// rephrase.
+func ReminderEvent(id int64, fire time.Time, payload string, dur time.Duration) Event {
+	if dur <= 0 {
+		dur = DefaultReminderDuration
+	}
+	summary := strings.TrimSpace(payload)
+	if summary == "" {
+		summary = "напоминание"
+	}
+	return Event{
+		UID:     fmt.Sprintf("%s%d", ReminderUIDPrefix, id),
+		Summary: summary,
+		Start:   fire,
+		End:     fire.Add(dur),
+	}
+}
+
+// ReminderPath is the collection-relative filename for a rendered reminder.
+// One event per resource, per the CalDAV convention.
+func ReminderPath(id int64) string {
+	return fmt.Sprintf("%s%d.ics", ReminderUIDPrefix, id)
+}

internal/config/config.go

@@ -140,6 +140,16 @@ type Config struct {
 	// item. See internal/morning for the evaluation engine. Empty ⇒ disabled.
 	MorningRoutines []MorningRoutineConfig `json:"morning_routines,omitempty"`
 
+	// PatternProposals — whether a routine the digestion tick inferred on its
+	// own may be announced, and how often. nil / absent ⇒ silent detection
+	// only: proposals are written for /routines and never announced. See
+	// PatternProposalConfig.
+	PatternProposals *PatternProposalConfig `json:"pattern_proposals,omitempty"`
+
+	// MemoryEval — background memory evaluation (internal/memeval). nil /
+	// absent ⇒ no evaluation loop at all. See MemoryEvalConfig.
+	MemoryEval *MemoryEvalConfig `json:"memory_eval,omitempty"`
+
 	// Praxis — the ecosystem attention-state service. When configured, maven
 	// calls the Praxis HTTP tools API for attention listing and item lifecycle.
 	// Maven never touches Praxis's database directly (ecosystem invariant: no
@@ -352,6 +362,62 @@ type DigestConfig struct {
 	SeverityCeiling int      `json:"severity_ceiling,omitempty"` // max sev batched
 }
 
+// PatternProposalConfig — announcement policy for routines the digestion tick
+// inferred by itself (Vikunja #247, #43).
+//
+// Detection is always on and always silent by default: the tick writes a
+// proposed_routines row and the /routines page shows it. Notify is what turns
+// "she noticed" into "she said something", and it is OFF unless configured —
+// Maven is not a nag and not autonomous, so a behaviour that speaks without
+// being asked has to be switched on deliberately, like weather and telegram.
+//
+// When Notify is on, the announcement is still heavily restrained:
+//   - at most one proposal per tick, however many were detected;
+//   - at most one per Cooldown across all pairs (not per pair), so a batch of
+//     freshly-detected patterns cannot turn into a queue of interruptions;
+//   - through the ordinary care-class gate (quiet hours / away / snooze), at
+//     sev1 — the lowest severity there is. A proposal is the least urgent
+//     thing Maven can say.
+//
+// A pair is only ever announced once, because it is only ever proposed once:
+// proposed_routines is UNIQUE(action, object) and the row survives dismissal.
+type PatternProposalConfig struct {
+	// Notify — announce newly inferred routines. Default false.
+	Notify bool `json:"notify,omitempty"`
+
+	// Cooldown — minimum spacing between two proposal announcements. 0 ⇒
+	// DefaultProposalCooldown (24h).
+	Cooldown Duration `json:"cooldown,omitempty"`
+}
+
+// AnnounceProposals reports whether inferred routines may be announced. Safe
+// on a nil receiver — an absent config block means silent detection.
+func (p *PatternProposalConfig) AnnounceProposals() bool {
+	return p != nil && p.Notify
+}
+
+// MemoryEvalConfig — the background memory-evaluation loop (Vikunja #248).
+// Absent ⇒ off, like every other capability that costs something the owner did
+// not ask for. Each evaluation is a full LLM round-trip on the one resident
+// model, which is the same model answering him; running it hourly by default
+// would put a multi-second stall in front of an occasional voice turn for a
+// feature he may not want.
+//
+// The loop only ever writes notes (source infer:memory-eval, visible on
+// /dash). It cannot speak — see internal/memeval.
+type MemoryEvalConfig struct {
+	// Interval — how often to evaluate. 0 ⇒ DefaultMemoryEvalInterval.
+	Interval Duration `json:"interval,omitempty"`
+
+	// MaxItems — recent facts / notes / nudges fed into one evaluation.
+	// 0 ⇒ memeval.DefaultMaxItems.
+	MaxItems int `json:"max_items,omitempty"`
+
+	// MinConfidence — observations the model scores below this are dropped.
+	// 0 ⇒ memeval.DefaultMinConfidence.
+	MinConfidence float64 `json:"min_confidence,omitempty"`
+}
+
 // PhraserConfig — the LLM-backed phraser seam. The daemon spawns llama-server
 // as a managed subprocess and sends chat-completion requests to phrase nudge
 // and reminder messages. nil ⇒ the template-based Stub is used instead.
@@ -448,6 +514,15 @@ const (
 	DefaultLLMRouter = true
 
 	DefaultFactEnrichmentInterval = 30 * time.Second
+
+	// DefaultProposalCooldown — one inferred-routine announcement per day at
+	// most. A proposal is never urgent; if two patterns surface in the same
+	// hour, the second one waits, and the /routines page has it either way.
+	DefaultProposalCooldown = 24 * time.Hour
+
+	// DefaultMemoryEvalInterval — the plan's cadence (1h) for the memory
+	// evaluation loop, applied only when the block is present at all.
+	DefaultMemoryEvalInterval = time.Hour
 )
 
 // Load reads the JSON config at path and applies defaults. A missing file is
@@ -520,6 +595,18 @@ func (c *Config) applyDefaults() {
 		c.Digest.SeverityCeiling = 2
 	}
 
+	// Absent block stays nil (⇒ silent detection). Present-but-partial gets the
+	// cooldown default, so `{"notify": true}` is enough to switch it on.
+	if c.PatternProposals != nil && c.PatternProposals.Cooldown <= 0 {
+		c.PatternProposals.Cooldown = Duration(DefaultProposalCooldown)
+	}
+
+	// Same rule: absent stays nil (⇒ no evaluation loop), present gets defaults
+	// so `{}` is a valid "on with the plan's cadence".
+	if c.MemoryEval != nil && c.MemoryEval.Interval <= 0 {
+		c.MemoryEval.Interval = Duration(DefaultMemoryEvalInterval)
+	}
+
 	if c.Voice != nil {
 		if c.Voice.RouterThreshold <= 0 {
 			c.Voice.RouterThreshold = DefaultRouterThreshold

internal/config/config_test.go

@@ -243,3 +243,53 @@ func TestDurationRoundTrip(t *testing.T) {
 		t.Errorf("round-trip = %v, want %v", d2, d)
 	}
 }
+
+// Both new opt-in capabilities follow the same rule: absent block ⇒ nil ⇒ the
+// behaviour does not exist. Presence is the enable act, so a bare `{}` block is
+// valid and gets the defaults filled in.
+func TestOptInBlocksAbsentStayNil(t *testing.T) {
+	c, err := Load(writeConfig(t, `{}`))
+	if err != nil {
+		t.Fatalf("Load: %v", err)
+	}
+	if c.PatternProposals != nil {
+		t.Errorf("pattern_proposals absent but got %+v", c.PatternProposals)
+	}
+	if c.PatternProposals.AnnounceProposals() {
+		t.Error("AnnounceProposals() true with no config block")
+	}
+	if c.MemoryEval != nil {
+		t.Errorf("memory_eval absent but got %+v", c.MemoryEval)
+	}
+}
+
+func TestOptInBlocksGetDefaultsWhenPresent(t *testing.T) {
+	c, err := Load(writeConfig(t, `{"pattern_proposals":{"notify":true},"memory_eval":{}}`))
+	if err != nil {
+		t.Fatalf("Load: %v", err)
+	}
+	if !c.PatternProposals.AnnounceProposals() {
+		t.Error("notify:true did not enable announcements")
+	}
+	if time.Duration(c.PatternProposals.Cooldown) != DefaultProposalCooldown {
+		t.Errorf("proposal cooldown = %v, want %v", c.PatternProposals.Cooldown, DefaultProposalCooldown)
+	}
+	if time.Duration(c.MemoryEval.Interval) != DefaultMemoryEvalInterval {
+		t.Errorf("memory eval interval = %v, want %v", c.MemoryEval.Interval, DefaultMemoryEvalInterval)
+	}
+}
+
+// Notify is off even when the block exists — the block is where you tune it,
+// notify:true is the act that lets her speak.
+func TestPatternProposalNotifyDefaultsOff(t *testing.T) {
+	c, err := Load(writeConfig(t, `{"pattern_proposals":{"cooldown":"6h"}}`))
+	if err != nil {
+		t.Fatalf("Load: %v", err)
+	}
+	if c.PatternProposals.AnnounceProposals() {
+		t.Error("notify defaulted to on")
+	}
+	if time.Duration(c.PatternProposals.Cooldown) != 6*time.Hour {
+		t.Errorf("cooldown = %v, want 6h", c.PatternProposals.Cooldown)
+	}
+}

internal/memeval/eval.go

@@ -0,0 +1,357 @@
+// Package memeval is background memory evaluation (Vikunja #248,
+// docs/plans/03-memory-evaluation.md).
+//
+// It lives beside internal/memory rather than inside it because
+// internal/store imports internal/memory for the vector-store backend, and an
+// evaluator has to read store.Fact / store.Note / store.Nudge — putting it in
+// internal/memory would close that import cycle.
+//
+// Every so often Maven reads back her own recent memory — facts, notes, the
+// nudges she sent — and asks the resident model what it notices: a habit that
+// stopped, a gap, something worth saying later. What comes back is written as
+// notes with source EvalNoteSource and nothing else happens. That restraint is
+// the design, not an unfinished edge:
+//
+//   - She does not speak here. There is no dispatcher, no channel, no nudge.
+//     An observation is a thought she wrote down; he reads it on /dash when he
+//     wants to. "Not a nag, not autonomous" (CLAUDE.md) is easy to violate with
+//     exactly this feature — an hourly loop with an LLM in it and permission to
+//     talk is a machine for generating interruptions — so the loop has no way
+//     to reach him at all. Turning observations into nudges is a separate
+//     decision with a separate opt-in, and it is deliberately NOT in this file.
+//   - She does not act. No reminder is created, no routine proposed, no fact
+//     written. The model's suggested_action is recorded as text inside the note
+//     and interpreted by nobody.
+//   - She says nothing about an empty store. No memory ⇒ no LLM call ⇒ no
+//     "observations" invented out of two facts. A 1.7B asked to find a pattern
+//     will always find one; the defence is not asking.
+//
+// Everything the evaluator writes is attributable: source is EvalNoteSource, so
+// an inferred observation can never be mistaken for something he said, and the
+// whole batch is one SQL delete away if the output turns out to be noise.
+package memeval
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/kami/maven/internal/llm"
+	"github.com/kami/maven/internal/persona"
+	"github.com/kami/maven/internal/store"
+)
+
+// EvalNoteSource — the source stamped on every note the evaluator writes.
+// Same infer:* convention as the rest of the derived facts.
+const EvalNoteSource = "infer:memory-eval"
+
+// DefaultMinConfidence — an observation below this is dropped. The model is
+// asked for its own confidence and small models are badly calibrated, so this
+// is a coarse filter, not a probability: it exists to throw away the guesses
+// the model itself hedged on.
+const DefaultMinConfidence = 0.7
+
+// DefaultMaxItems — how much recent memory goes into one evaluation, per
+// store. 30 facts + 30 notes + 30 nudges is a few thousand tokens of the 4096
+// context the resident Thinking model runs with, which leaves room for its
+// reasoning tokens. Raising this trades reasoning room for history.
+const DefaultMaxItems = 30
+
+// MaxObservations — the model may return at most this many observations per
+// evaluation, enforced by the grammar. A cap here is also a noise cap: an
+// evaluation that "notices" ten things has noticed nothing.
+const MaxObservations = 3
+
+// Observation — one thing the evaluator noticed.
+type Observation struct {
+	Text string  `json:"observation"`
+	Conf float64 `json:"confidence"`
+	// Action — what the model thinks should happen with this. Recorded, never
+	// executed: see the file comment. One of "note", "propose", "notify".
+	Action string `json:"suggested_action"`
+}
+
+// Completer — the llama-server seam, same shape router.Completer uses so the
+// one resident model serves this caller too.
+type Completer interface {
+	Complete(ctx context.Context, r llm.Req) (string, error)
+}
+
+// Reader — the slice of the store an evaluation reads. Narrow on purpose: the
+// evaluator gets recent memory and nothing else. No entity graph, no presence,
+// no config facts.
+type Reader interface {
+	RecentFacts(ctx context.Context, n int) ([]store.Fact, error)
+	RecentNotes(ctx context.Context, n int) ([]store.Note, error)
+	RecentNudges(ctx context.Context, n int) ([]store.Nudge, error)
+}
+
+// NoteWriter — where observations land. Embeddings are passed nil: an
+// observation is written for a human to read on /dash, not to be recalled by
+// similarity. Feeding LLM-generated text back into the RAG pool it was
+// generated from is how a small model starts citing its own guesses as
+// evidence.
+type NoteWriter interface {
+	WriteNote(ctx context.Context, ts time.Time, text string, embedding []float32, source string) (int64, error)
+}
+
+// Config — evaluator tuning. Zero values are replaced by the Default*
+// constants, so the zero Config is the sane one.
+type Config struct {
+	MaxItems      int
+	MinConfidence float64
+
+	// ContextBlock — the shared persona block (internal/persona), re-evaluated
+	// per call so the clock in it is current. Prepended to the system prompt so
+	// observations come out in Maven's voice: feminine self-reference, informal
+	// "ты". nil is allowed; the base prompt still carries the address rules.
+	ContextBlock func() string
+}
+
+// Evaluator reads recent memory and records what the model notices.
+type Evaluator struct {
+	read  Reader
+	write NoteWriter
+	llm   Completer
+	cfg   Config
+}
+
+func NewEvaluator(r Reader, w NoteWriter, c Completer, cfg Config) *Evaluator {
+	if cfg.MaxItems <= 0 {
+		cfg.MaxItems = DefaultMaxItems
+	}
+	if cfg.MinConfidence <= 0 {
+		cfg.MinConfidence = DefaultMinConfidence
+	}
+	return &Evaluator{read: r, write: w, llm: c, cfg: cfg}
+}
+
+// evalGrammar — GBNF pinning the reply to a bounded JSON array of fixed-shape
+// observations. Same reasoning as the router's routeGrammar: the enum and the
+// length bound are what stop a small model from drifting into free text or
+// filling the token budget with one repeated field.
+const evalGrammar = `
+root   ::= "[" ws (obs ("," ws obs){0,2})? ws "]"
+obs    ::= "{" ws "\"observation\"" ws ":" ws text "," ws "\"confidence\"" ws ":" ws conf "," ws "\"suggested_action\"" ws ":" ws act ws "}"
+text   ::= "\"" ([^"\\] | "\\" .){1,200} "\""
+conf   ::= "0" "." [0-9]{1,2} | "1" ("." "0")?
+act    ::= "\"note\"" | "\"propose\"" | "\"notify\""
+ws     ::= [ \t\n]*
+`
+
+// evalSystem — the evaluation prompt. Two things it insists on, both learned
+// from the phraser: state the observation as something she noticed rather than
+// an instruction, and say nothing when there is nothing (the model is given an
+// explicit way to return an empty array, because a model with no exit returns
+// filler).
+const evalSystem = `Ты просматриваешь свою собственную память: недавние факты, заметки и напоминания, которые ты отправляла.
+Найди то, что действительно заметно: привычка, которая прервалась; пробел в записях; повторяющаяся закономерность.
+
+Правила:
+- Отвечай ТОЛЬКО массивом JSON. Каждый элемент: {"observation": "...", "confidence": 0.0-1.0, "suggested_action": "note"|"propose"|"notify"}.
+- observation — короткая фраза по-русски о том, что ты заметила. О себе — в женском роде ("я заметила"). К нему — на "ты".
+- Не выдумывай. Если в памяти нет ничего заметного, верни пустой массив [].
+- Не давай советов и не приказывай. Ты замечаешь, а не требуешь.
+- confidence — насколько ты уверена, что это настоящая закономерность, а не совпадение.
+- Максимум три наблюдения. Лучше одно точное, чем три общих.`
+
+// Evaluate runs one evaluation and returns the observations it recorded.
+//
+// Returns (nil, nil) — not an error — for every ordinary "nothing to say"
+// outcome: an empty store, an empty array from the model, everything below the
+// confidence floor, or every observation already recorded earlier. Only a real
+// read/LLM/write failure is an error, and the caller (a background ticker) logs
+// it and waits for the next interval.
+func (e *Evaluator) Evaluate(ctx context.Context, now time.Time) ([]Observation, error) {
+	snap, err := e.snapshot(ctx)
+	if err != nil {
+		return nil, err
+	}
+	if snap == "" {
+		return nil, nil // nothing recorded ⇒ nothing to notice, and no LLM call
+	}
+
+	raw, err := e.llm.Complete(ctx, llm.Req{
+		System:        persona.Prepend(e.cfg.ContextBlock, evalSystem),
+		User:          snap,
+		Grammar:       evalGrammar,
+		MaxTokens:     512,
+		RepeatPenalty: 1.1,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("memory eval: complete: %w", err)
+	}
+	obs, err := parseObservations(raw)
+	if err != nil {
+		return nil, fmt.Errorf("memory eval: parse %q: %w", truncate(raw, 120), err)
+	}
+
+	// Dedupe against what earlier evaluations already wrote. Without this an
+	// hourly loop over a slowly-changing store writes the same sentence every
+	// hour until /dash is nothing but the evaluator talking to itself.
+	seen, err := e.recordedTexts(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	var kept []Observation
+	for _, o := range obs {
+		o.Text = strings.TrimSpace(o.Text)
+		if o.Text == "" || o.Conf < e.cfg.MinConfidence {
+			continue
+		}
+		norm := normalizeObservation(o.Text)
+		if seen[norm] {
+			continue
+		}
+		seen[norm] = true
+		if _, err := e.write.WriteNote(ctx, now, formatNote(o), nil, EvalNoteSource); err != nil {
+			return kept, fmt.Errorf("memory eval: write note: %w", err)
+		}
+		kept = append(kept, o)
+	}
+	return kept, nil
+}
+
+// formatNote — the stored text. The suggested action is kept as a visible
+// suffix rather than a column: it is the model's opinion about what to do next,
+// and the only consumer is a human reading /dash.
+func formatNote(o Observation) string {
+	if o.Action == "" {
+		return o.Text
+	}
+	return fmt.Sprintf("%s [%s]", o.Text, o.Action)
+}
+
+// recordedTexts — the normalized text of every observation earlier evaluations
+// wrote, for dedupe. Reads a wider window than MaxItems because the point is to
+// remember saying it, not to summarize it.
+func (e *Evaluator) recordedTexts(ctx context.Context) (map[string]bool, error) {
+	notes, err := e.read.RecentNotes(ctx, 200)
+	if err != nil {
+		return nil, fmt.Errorf("memory eval: recent notes: %w", err)
+	}
+	seen := make(map[string]bool, len(notes))
+	for _, n := range notes {
+		if n.Source != EvalNoteSource {
+			continue
+		}
+		text := n.Text
+		// Strip the "[action]" suffix formatNote appended.
+		if i := strings.LastIndex(text, " ["); i > 0 && strings.HasSuffix(text, "]") {
+			text = text[:i]
+		}
+		seen[normalizeObservation(text)] = true
+	}
+	return seen, nil
+}
+
+// normalizeObservation — dedupe key. Case- and whitespace-insensitive, which
+// catches the realistic repeat (the model re-emitting the same sentence with a
+// different comma) without pretending to do semantic dedupe.
+func normalizeObservation(s string) string {
+	return strings.Join(strings.Fields(strings.ToLower(s)), " ")
+}
+
+// snapshot renders recent memory as the user turn. Returns "" when there is
+// nothing in any store — the caller treats that as "do not ask the model".
+//
+// Notes written by earlier evaluations are excluded. Feeding her own
+// observations back in is how "я заметила, что ты не записывал еду" becomes
+// evidence for noticing it again, three evaluations deep.
+func (e *Evaluator) snapshot(ctx context.Context) (string, error) {
+	n := e.cfg.MaxItems
+	facts, err := e.read.RecentFacts(ctx, n)
+	if err != nil {
+		return "", fmt.Errorf("memory eval: recent facts: %w", err)
+	}
+	notes, err := e.read.RecentNotes(ctx, n)
+	if err != nil {
+		return "", fmt.Errorf("memory eval: recent notes: %w", err)
+	}
+	nudges, err := e.read.RecentNudges(ctx, n)
+	if err != nil {
+		return "", fmt.Errorf("memory eval: recent nudges: %w", err)
+	}
+
+	var b strings.Builder
+	wrote := false
+	if len(facts) > 0 {
+		b.WriteString("Факты:\n")
+		for _, f := range facts {
+			fmt.Fprintf(&b, "- %s %s=%s (%s)\n", f.Ts.Format("2006-01-02 15:04"), f.Key, truncate(f.Value, 80), f.Source)
+			wrote = true
+		}
+	}
+	own := 0
+	var noteLines []string
+	for _, nt := range notes {
+		if nt.Source == EvalNoteSource {
+			own++
+			continue
+		}
+		noteLines = append(noteLines, fmt.Sprintf("- %s %s\n", nt.Ts.Format("2006-01-02 15:04"), truncate(nt.Text, 160)))
+	}
+	if len(noteLines) > 0 {
+		b.WriteString("\nЗаметки:\n")
+		for _, l := range noteLines {
+			b.WriteString(l)
+			wrote = true
+		}
+	}
+	if len(nudges) > 0 {
+		b.WriteString("\nНапоминания, которые ты отправляла:\n")
+		for _, nd := range nudges {
+			outcome := nd.Outcome
+			if outcome == "" {
+				outcome = "?"
+			}
+			fmt.Fprintf(&b, "- %s %s → %s (%s)\n", nd.Ts.Format("2006-01-02 15:04"), nd.Rule, outcome, nd.Channel)
+			wrote = true
+		}
+	}
+	if !wrote {
+		// Only her own past observations, or nothing at all. Either way there is
+		// no new memory to evaluate.
+		return "", nil
+	}
+	b.WriteString("\nЧто ты замечаешь?")
+	return b.String(), nil
+}
+
+// parseObservations reads the model's array. Tolerates the leading/trailing
+// prose a Thinking model sometimes emits around JSON by taking the outermost
+// bracketed span, the same tolerance the router's parser has.
+func parseObservations(raw string) ([]Observation, error) {
+	s := strings.TrimSpace(raw)
+	if i := strings.Index(s, "["); i >= 0 {
+		if j := strings.LastIndex(s, "]"); j > i {
+			s = s[i : j+1]
+		}
+	}
+	if s == "" {
+		return nil, nil
+	}
+	var obs []Observation
+	if err := json.Unmarshal([]byte(s), &obs); err != nil {
+		return nil, err
+	}
+	if len(obs) > MaxObservations {
+		// The grammar bounds this; a grammar-less server or a future prompt
+		// change must not be able to flood /dash.
+		sort.SliceStable(obs, func(i, j int) bool { return obs[i].Conf > obs[j].Conf })
+		obs = obs[:MaxObservations]
+	}
+	return obs, nil
+}
+
+func truncate(s string, n int) string {
+	r := []rune(s)
+	if len(r) <= n {
+		return s
+	}
+	return string(r[:n]) + "…"
+}

internal/memeval/eval_test.go

@@ -0,0 +1,271 @@
+package memeval
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/kami/maven/internal/llm"
+	"github.com/kami/maven/internal/store"
+)
+
+// fakeLLM — canned replies, one per call, and a record of what it was asked.
+type fakeLLM struct {
+	replies []string
+	calls   []llm.Req
+	err     error
+}
+
+func (f *fakeLLM) Complete(_ context.Context, r llm.Req) (string, error) {
+	f.calls = append(f.calls, r)
+	if f.err != nil {
+		return "", f.err
+	}
+	if len(f.replies) == 0 {
+		return "[]", nil
+	}
+	out := f.replies[0]
+	f.replies = f.replies[1:]
+	return out, nil
+}
+
+func newTestStore(t *testing.T) *store.Store {
+	t.Helper()
+	st, err := store.Open(context.Background(), filepath.Join(t.TempDir(), "memeval_test.db"))
+	if err != nil {
+		t.Fatalf("store.Open: %v", err)
+	}
+	t.Cleanup(func() { _ = st.Close() })
+	return st
+}
+
+func refNow() time.Time { return time.Date(2026, 8, 1, 9, 0, 0, 0, time.UTC) }
+
+// seedMemory writes a little of everything the evaluator reads.
+func seedMemory(t *testing.T, st *store.Store, ctx context.Context, now time.Time) {
+	t.Helper()
+	for i := 0; i < 3; i++ {
+		ts := now.Add(-time.Duration(i+1) * 24 * time.Hour)
+		if _, err := st.WriteFact(ctx, ts, store.KindSelf, "water_ml", "500", "tap:desk", 1.0, sql.NullInt64{}); err != nil {
+			t.Fatalf("write fact: %v", err)
+		}
+	}
+	if _, err := st.WriteNote(ctx, now.Add(-2*time.Hour), "купить корм для кота", nil, "tap:voice"); err != nil {
+		t.Fatalf("write note: %v", err)
+	}
+	if _, err := st.RecordNudge(ctx, "water", "voice", "пора выпить воды", now.Add(-time.Hour)); err != nil {
+		t.Fatalf("record nudge: %v", err)
+	}
+}
+
+// TestEvaluateEmptyStoreAsksNothing — the "shuts up when uncertain" floor. An
+// empty store must not even reach the model: a small model asked to find a
+// pattern in nothing will invent one.
+func TestEvaluateEmptyStoreAsksNothing(t *testing.T) {
+	st := newTestStore(t)
+	ctx := context.Background()
+	f := &fakeLLM{}
+	ev := NewEvaluator(st, st, f, Config{})
+
+	obs, err := ev.Evaluate(ctx, refNow())
+	if err != nil {
+		t.Fatalf("Evaluate: %v", err)
+	}
+	if len(obs) != 0 {
+		t.Fatalf("observations on an empty store = %d, want 0", len(obs))
+	}
+	if len(f.calls) != 0 {
+		t.Fatalf("LLM called %d times on an empty store, want 0", len(f.calls))
+	}
+}
+
+// TestEvaluateWritesHighConfidenceObservations — the happy path. Confident
+// observations are written as notes stamped infer:memory-eval, and the low
+// ones are dropped.
+func TestEvaluateWritesHighConfidenceObservations(t *testing.T) {
+	st := newTestStore(t)
+	ctx := context.Background()
+	now := refNow()
+	seedMemory(t, st, ctx, now)
+
+	f := &fakeLLM{replies: []string{`[
+		{"observation":"ты три дня не записывал еду","confidence":0.9,"suggested_action":"notify"},
+		{"observation":"может быть, ты стал меньше пить воды","confidence":0.3,"suggested_action":"note"}
+	]`}}
+	ev := NewEvaluator(st, st, f, Config{})
+
+	obs, err := ev.Evaluate(ctx, now)
+	if err != nil {
+		t.Fatalf("Evaluate: %v", err)
+	}
+	if len(obs) != 1 {
+		t.Fatalf("kept %d observations, want 1 (the 0.3 one is below the floor): %+v", len(obs), obs)
+	}
+	if obs[0].Text != "ты три дня не записывал еду" {
+		t.Errorf("kept the wrong observation: %q", obs[0].Text)
+	}
+
+	notes, err := st.RecentNotes(ctx, 50)
+	if err != nil {
+		t.Fatalf("RecentNotes: %v", err)
+	}
+	var written []store.Note
+	for _, n := range notes {
+		if n.Source == EvalNoteSource {
+			written = append(written, n)
+		}
+	}
+	if len(written) != 1 {
+		t.Fatalf("notes with source %s = %d, want 1", EvalNoteSource, len(written))
+	}
+	if !strings.Contains(written[0].Text, "ты три дня не записывал еду") {
+		t.Errorf("note text = %q", written[0].Text)
+	}
+	if !strings.Contains(written[0].Text, "[notify]") {
+		t.Errorf("note text = %q, want the suggested action recorded", written[0].Text)
+	}
+
+	// The prompt must carry the memory it is evaluating, and must not carry a
+	// grammar-free request.
+	if len(f.calls) != 1 {
+		t.Fatalf("LLM calls = %d, want 1", len(f.calls))
+	}
+	if !strings.Contains(f.calls[0].User, "water_ml") {
+		t.Errorf("prompt does not mention the seeded facts:\n%s", f.calls[0].User)
+	}
+	if f.calls[0].Grammar == "" {
+		t.Error("evaluation ran without a grammar")
+	}
+}
+
+// TestEvaluateDeduplicatesAcrossRuns — the failure mode that would make this
+// feature unusable: an hourly loop over a store that barely changes writing the
+// same sentence every hour until /dash is nothing but the evaluator.
+func TestEvaluateDeduplicatesAcrossRuns(t *testing.T) {
+	st := newTestStore(t)
+	ctx := context.Background()
+	now := refNow()
+	seedMemory(t, st, ctx, now)
+
+	same := `[{"observation":"ты три дня не записывал еду","confidence":0.9,"suggested_action":"note"}]`
+	spaced := `[{"observation":"Ты  три дня   не записывал еду","confidence":0.95,"suggested_action":"note"}]`
+	f := &fakeLLM{replies: []string{same, same, spaced}}
+	ev := NewEvaluator(st, st, f, Config{})
+
+	for i := 0; i < 3; i++ {
+		if _, err := ev.Evaluate(ctx, now.Add(time.Duration(i)*time.Hour)); err != nil {
+			t.Fatalf("Evaluate %d: %v", i, err)
+		}
+	}
+
+	notes, err := st.RecentNotes(ctx, 50)
+	if err != nil {
+		t.Fatalf("RecentNotes: %v", err)
+	}
+	n := 0
+	for _, nt := range notes {
+		if nt.Source == EvalNoteSource {
+			n++
+		}
+	}
+	if n != 1 {
+		t.Fatalf("eval notes after three identical evaluations = %d, want 1", n)
+	}
+}
+
+// TestEvaluateIgnoresOwnNotes — her own observations must not become input.
+// Otherwise "я заметила X" is evidence for noticing X again, three evaluations
+// deep. With nothing but eval notes in the store there is no new memory, so the
+// model is not asked at all.
+func TestEvaluateIgnoresOwnNotes(t *testing.T) {
+	st := newTestStore(t)
+	ctx := context.Background()
+	now := refNow()
+	if _, err := st.WriteNote(ctx, now.Add(-time.Hour), "я заметила, что ты мало пьёшь [note]", nil, EvalNoteSource); err != nil {
+		t.Fatalf("write note: %v", err)
+	}
+
+	f := &fakeLLM{}
+	ev := NewEvaluator(st, st, f, Config{})
+	obs, err := ev.Evaluate(ctx, now)
+	if err != nil {
+		t.Fatalf("Evaluate: %v", err)
+	}
+	if len(obs) != 0 || len(f.calls) != 0 {
+		t.Fatalf("observations=%d llm calls=%d, want 0/0 — own notes are not memory to evaluate", len(obs), len(f.calls))
+	}
+}
+
+// TestEvaluateEmptyArrayIsNotAnError — "nothing to say" is the expected outcome
+// most of the time and must not be logged as a failure.
+func TestEvaluateEmptyArrayIsNotAnError(t *testing.T) {
+	st := newTestStore(t)
+	ctx := context.Background()
+	now := refNow()
+	seedMemory(t, st, ctx, now)
+
+	ev := NewEvaluator(st, st, &fakeLLM{replies: []string{"[]"}}, Config{})
+	obs, err := ev.Evaluate(ctx, now)
+	if err != nil {
+		t.Fatalf("Evaluate: %v", err)
+	}
+	if len(obs) != 0 {
+		t.Fatalf("observations = %d, want 0", len(obs))
+	}
+}
+
+// TestEvaluateLLMErrorIsReported — a broken llama-server is an error the caller
+// logs; it must not silently write anything.
+func TestEvaluateLLMErrorIsReported(t *testing.T) {
+	st := newTestStore(t)
+	ctx := context.Background()
+	now := refNow()
+	seedMemory(t, st, ctx, now)
+
+	ev := NewEvaluator(st, st, &fakeLLM{err: errors.New("connection refused")}, Config{})
+	if _, err := ev.Evaluate(ctx, now); err == nil {
+		t.Fatal("want an error when the model is unreachable")
+	}
+	notes, err := st.RecentNotes(ctx, 50)
+	if err != nil {
+		t.Fatalf("RecentNotes: %v", err)
+	}
+	for _, n := range notes {
+		if n.Source == EvalNoteSource {
+			t.Fatalf("wrote a note despite an LLM failure: %q", n.Text)
+		}
+	}
+}
+
+// TestParseObservationsTolerantAndBounded — Thinking models wrap JSON in prose,
+// and no reply may exceed MaxObservations even if the grammar is bypassed.
+func TestParseObservationsTolerantAndBounded(t *testing.T) {
+	obs, err := parseObservations(`<think>hmm</think> вот: [{"observation":"a","confidence":0.9,"suggested_action":"note"}] всё`)
+	if err != nil {
+		t.Fatalf("parse: %v", err)
+	}
+	if len(obs) != 1 || obs[0].Text != "a" {
+		t.Fatalf("got %+v, want one observation 'a'", obs)
+	}
+
+	var b strings.Builder
+	b.WriteString("[")
+	for i := 0; i < MaxObservations+3; i++ {
+		if i > 0 {
+			b.WriteString(",")
+		}
+		b.WriteString(`{"observation":"x","confidence":0.5,"suggested_action":"note"}`)
+	}
+	b.WriteString("]")
+	obs, err = parseObservations(b.String())
+	if err != nil {
+		t.Fatalf("parse: %v", err)
+	}
+	if len(obs) != MaxObservations {
+		t.Fatalf("parsed %d observations, want the %d cap", len(obs), MaxObservations)
+	}
+}

internal/pattern/detector.go

@@ -20,9 +20,19 @@ type ProposedRoutine struct {
 const MaxIntervalRatio = 1.5
 
 // MinEvents is the minimum number of events needed to detect a pattern.
-// With N events, there are N-1 intervals; we need at least 2 intervals
-// before proposing anything.
-const MinEvents = 3
+// With N events there are N-1 intervals, so 4 events means 3 intervals.
+//
+// This used to be 3 (two intervals), which is not a pattern — it is a
+// coincidence with a mean. Two gaps of similar length happen constantly:
+// water the plants on a Sunday, again the next Sunday, once more the Sunday
+// after, and a detector with a ±50% band calls that a weekly routine. The
+// cost of being wrong is asymmetric now that the digestion tick scans all of
+// history on its own schedule and can announce what it finds: a false
+// positive is something the owner has to read and dismiss, and a dismissal
+// is permanent, so one bad guess burns that action+object pair forever.
+// Three intervals is the cheapest bar that makes a run distinguishable from
+// a repeat. False negatives cost one more observation and nothing else.
+const MinEvents = 4
 
 // Detect checks whether a sequence of events for the same action+object
 // forms a stable recurring pattern. Returns a ProposedRoutine when:

internal/pattern/detector_test.go

@@ -6,12 +6,13 @@ import (
 )
 
 func TestDetectEnoughEvents(t *testing.T) {
-	// 3 events with 7-day intervals → stable pattern
+	// MinEvents events with 7-day intervals → stable pattern
 	base := time.Date(2026, 7, 1, 12, 0, 0, 0, time.UTC)
 	events := []Event{
 		{Action: "refill", Object: "cat_water", Ts: base},
 		{Action: "refill", Object: "cat_water", Ts: base.Add(7 * 24 * time.Hour)},
 		{Action: "refill", Object: "cat_water", Ts: base.Add(14 * 24 * time.Hour)},
+		{Action: "refill", Object: "cat_water", Ts: base.Add(21 * 24 * time.Hour)},
 	}
 
 	r, err := Detect(events)
@@ -24,8 +25,8 @@ func TestDetectEnoughEvents(t *testing.T) {
 	if r.Action != "refill" || r.Object != "cat_water" {
 		t.Fatalf("action/object: want refill/cat_water, got %s/%s", r.Action, r.Object)
 	}
-	if r.N != 3 {
-		t.Fatalf("want N=3, got %d", r.N)
+	if r.N != 4 {
+		t.Fatalf("want N=4, got %d", r.N)
 	}
 	// ~7 days
 	if r.IntervalDays < 6.9 || r.IntervalDays > 7.1 {
@@ -33,19 +34,28 @@ func TestDetectEnoughEvents(t *testing.T) {
 	}
 }
 
+// TestDetectNotEnoughEvents — two intervals are a coincidence, not a routine
+// (Vikunja #43). Three same-day-of-week events used to be enough to propose a
+// weekly reminder; MinEvents is 4 now so a repeat has to happen a third time
+// before Maven calls it a pattern.
 func TestDetectNotEnoughEvents(t *testing.T) {
 	base := time.Date(2026, 7, 1, 12, 0, 0, 0, time.UTC)
-	events := []Event{
-		{Action: "refill", Object: "cat_water", Ts: base},
-		{Action: "refill", Object: "cat_water", Ts: base.Add(7 * 24 * time.Hour)},
-	}
-
-	r, err := Detect(events)
-	if err != nil {
-		t.Fatalf("Detect: %v", err)
-	}
-	if r != nil {
-		t.Fatal("want nil for <3 events")
+	for _, n := range []int{1, 2, MinEvents - 1} {
+		events := make([]Event, n)
+		for i := range events {
+			events[i] = Event{
+				Action: "refill",
+				Object: "cat_water",
+				Ts:     base.Add(time.Duration(i) * 7 * 24 * time.Hour),
+			}
+		}
+		r, err := Detect(events)
+		if err != nil {
+			t.Fatalf("Detect(%d events): %v", n, err)
+		}
+		if r != nil {
+			t.Fatalf("Detect(%d events) proposed %+v, want nil below MinEvents=%d", n, r, MinEvents)
+		}
 	}
 }
 
@@ -68,12 +78,13 @@ func TestDetectEmpty(t *testing.T) {
 }
 
 func TestDetectIrregularRejects(t *testing.T) {
-	// 3 events but wildly irregular: 1 day, then 14 days → ratio 14 > 1.5
+	// wildly irregular: 1 day, then 14 days → ratio 14 > 1.5
 	base := time.Date(2026, 7, 1, 12, 0, 0, 0, time.UTC)
 	events := []Event{
 		{Action: "refill", Object: "cat_water", Ts: base},
 		{Action: "refill", Object: "cat_water", Ts: base.Add(1 * 24 * time.Hour)},
 		{Action: "refill", Object: "cat_water", Ts: base.Add(15 * 24 * time.Hour)},
+		{Action: "refill", Object: "cat_water", Ts: base.Add(16 * 24 * time.Hour)},
 	}
 
 	r, err := Detect(events)
@@ -117,6 +128,7 @@ func TestDetectSameTimestamp(t *testing.T) {
 		{Action: "refill", Object: "cat_water", Ts: base},
 		{Action: "refill", Object: "cat_water", Ts: base},
 		{Action: "refill", Object: "cat_water", Ts: base.Add(7 * 24 * time.Hour)},
+		{Action: "refill", Object: "cat_water", Ts: base.Add(14 * 24 * time.Hour)},
 	}
 
 	r, err := Detect(events)