Run pattern detection from the digestion tick, not just voice (#43)

detectPattern only ever fired as a side effect of a voice fact-write, so a
recurring pattern already sitting in history went unnoticed until he
happened to mention it again by voice — the opposite of proactive.

Split the pipeline: extraction (fact -> normalized event) stays where a fact
is written, in voice.go, since it's tied to that write regardless of who's
talking. Detection (events -> stable pattern -> proposed_routines row) moves
into shared code (patterns.go's detectAndPropose) that both the voice path
and the new tick.go:detectPatterns call. The tick runs it every cycle over
every action+object pair on record (store.DistinctEventPairs, added), so a
pattern gets noticed on the daemon's own schedule.

Idempotence and the dismiss-must-stick requirement turned out to already be
handled by the store, not something the tick needs to reinvent:
proposed_routines has UNIQUE(action, object) and CreateProposedRoutine does
ON CONFLICT DO NOTHING, and DismissProposedRoutine flips status in place
without deleting the row. So a pair already proposed, accepted, OR
dismissed is a silent no-op on every later tick — a dismissed pattern can
never resurface, and re-running the scan never spams the /routines page.
Kept the voice-path call (immediate spoken confirmation is a nice feature
UX-wise and is now redundant-but-harmless with the tick, since both paths
share the same guarded detectAndPropose).

Tick-side detection only ever writes a row; it does not notify, ring, or
speak, keeping Maven "not a nag, not autonomous" — the /routines page is
still the only place a proposal becomes visible, and only accepting it
starts producing nudges (fireAcceptedRoutines).

Also fixed the stale vikunja#46 reference in proposed_routines.go — the
TODO it named is what this commit does.

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

cmd/mavend/voice.go

@@ -874,42 +874,19 @@ func (h *reactiveHandler) detectPattern(ctx context.Context, factID int64, key,
 		log.Printf("voice: create event: %v", err)
 		return ""
 	}
-	events, err := h.dataStore.EventsFor(ctx, ev.Action, ev.Object)
+	// Detect+propose (Vikunja #43) is shared with the digestion tick's
+	// proactive scan — see patterns.go. Event *extraction* above stays here,
+	// tied to this fact write; detection over the accumulated history does
+	// not need to happen right now for the voice path to have already done
+	// its job — it's dedupe-safe to also let the next tick find the same
+	// pattern independently.
+	r, id, err := detectAndPropose(ctx, h.dataStore, ev.Action, ev.Object, ts)
 	if err != nil {
-		log.Printf("voice: events for %s/%s: %v", ev.Action, ev.Object, err)
-		return ""
-	}
-	// Convert store.Events to pattern.Events for the detector.
-	patEvents := make([]pattern.Event, len(events))
-	for i, e := range events {
-		patEvents[i] = pattern.Event{
-			FactID: e.FactID,
-			Action: e.Action,
-			Object: e.Object,
-			Ts:     e.Ts,
-		}
-	}
-	r, err := pattern.Detect(patEvents)
-	if err != nil {
-		log.Printf("voice: pattern detect: %v", err)
+		log.Printf("voice: detect pattern %s/%s: %v", ev.Action, ev.Object, err)
 		return ""
 	}
 	if r == nil {
-		return "" // not enough data or intervals too irregular
-	}
-	// Check if already proposed/accepted/dismissed for this pair.
-	existing, err := h.dataStore.LookupProposedRoutine(ctx, r.Action, r.Object)
-	if err != nil {
-		log.Printf("voice: lookup proposed routine: %v", err)
-		return ""
-	}
-	if existing != nil {
-		return "" // already proposed, accepted, or dismissed
-	}
-	id, err := h.dataStore.CreateProposedRoutine(ctx, r.Action, r.Object, r.IntervalDays, ts)
-	if err != nil {
-		log.Printf("voice: create proposed routine: %v", err)
-		return ""
+		return "" // not enough data, too irregular, or already proposed/decided
 	}
 	log.Printf("voice: proposed routine: %s/%s every %.1f days", r.Action, r.Object, r.IntervalDays)