Add the morning routine engine — a daily checklist, not four timers

Backlog item #3 (20-07-2026-BACKLOG.md). A morning routine is a checklist for
a daily window: several items, each evidenced by a fact key, completed in any
order, checked once near the end of the window. Modelling it as four
independent reminder timers would stack into exactly the kind of noise Maven is
supposed not to produce, so the engine nags at most once per day per routine
and only for what is actually still missing.

internal/morning follows the established pure-engine pattern (loop, routine,
pattern): no store, no clock of its own. Evaluate answers "what's still
missing" at any point; Due decides whether to nag. The impurity — reading
facts under the store lock, holding the last-nudge map across ticks — stays in
the tick driver, which calls Due each tick exactly as it does for loop.Rule
and routine.Routine.

Completion evidence is a fact key's latest non-voided value timestamped inside
today's window, so manual ("выпил воды", voice-tapped) and inferred (another
daemon writing the same key) are indistinguishable and both count. Weekdays
scopes which days a routine applies to, so weekday/weekend variants are two
routine rows rather than a special case in the engine.

Exposed read-only: a MorningStatus RPC over ipc, and a /morning page in mavweb
built on the same server-rendered shape as /trace — no live-update loop, since
checklist state moves on the scale of minutes.

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

internal/ipc/api.go

@@ -292,6 +292,13 @@ type CoreAPI interface {
 	// persisted — it's a daemon-level cache).
 	TickTrace(ctx context.Context) (TickTrace, error)
 
+	// MorningStatus returns each configured morning routine's current
+	// checklist state (see internal/morning): active today/now, which items
+	// are done, which are still missing. The store adapter returns an error
+	// (morning routines are daemon-config, not persisted) — same shape as
+	// TickTrace.
+	MorningStatus(ctx context.Context) ([]MorningRoutineStatus, error)
+
 	// Chat routes a text utterance through the reactive handler's core path
 	// (router → dialogue → action → replier) and returns the reply text.
 	// No audio or stt/tts — for text channels (mavweb, telegram).
@@ -329,6 +336,22 @@ type TickTrace struct {
 	Rules  []RuleTrace `json:"rules"`
 }
 
+// MorningRoutineItem — one checklist entry's current state.
+type MorningRoutineItem struct {
+	Key   string `json:"key"`
+	Label string `json:"label"`
+	Done  bool   `json:"done"`
+}
+
+// MorningRoutineStatus — one routine's checklist state right now.
+type MorningRoutineStatus struct {
+	Name        string               `json:"name"`
+	Active      bool                 `json:"active"`
+	WindowStart string               `json:"window_start"`
+	WindowEnd   string               `json:"window_end"`
+	Items       []MorningRoutineItem `json:"items"`
+}
+
 // storeEncryptionKeyReq — passkey credential public key for wrapping the store
 // encryption key at enrollment time. Called by mavweb after RegisterFinish.
 type storeEncryptionKeyReq struct {

internal/ipc/client.go

@@ -70,6 +70,7 @@ var readOnlyMethods = map[Method]bool{
 	MethodListTools:            true,
 	MethodListProposedRoutines: true,
 	MethodTickTrace:            true,
+	MethodMorningStatus:        true,
 }
 
 // Dial connects to a core socket at path and returns a Client. The module
@@ -445,6 +446,14 @@ func (c *Client) TickTrace(ctx context.Context) (TickTrace, error) {
 	return t, nil
 }
 
+func (c *Client) MorningStatus(ctx context.Context) ([]MorningRoutineStatus, error) {
+	var s []MorningRoutineStatus
+	if err := c.call(ctx, MethodMorningStatus, nil, &s); err != nil {
+		return nil, err
+	}
+	return s, nil
+}
+
 func (c *Client) RevertFact(ctx context.Context, key string) (int64, error) {
 	var result struct {
 		NewID int64 `json:"new_id"`

internal/ipc/ipc_test.go

@@ -493,6 +493,9 @@ func (a *chatTestAPI) RevertFact(ctx context.Context, key string) (int64, error)
 func (a *chatTestAPI) TickTrace(ctx context.Context) (TickTrace, error) {
 	return TickTrace{}, ErrUnknownMethod
 }
+func (a *chatTestAPI) MorningStatus(ctx context.Context) ([]MorningRoutineStatus, error) {
+	return nil, ErrUnknownMethod
+}
 func (a *chatTestAPI) Chat(ctx context.Context, text string) (string, error) {
 	if text == "привет" {
 		return "и тебе привет!", nil

internal/ipc/server.go

@@ -207,6 +207,10 @@ func (a *storeAPI) TickTrace(ctx context.Context) (TickTrace, error) {
 	return TickTrace{}, errors.New("store: tick trace not available via direct store API")
 }
 
+func (a *storeAPI) MorningStatus(ctx context.Context) ([]MorningRoutineStatus, error) {
+	return nil, errors.New("store: morning status not available via direct store API")
+}
+
 func (a *storeAPI) ListTools(ctx context.Context, status string) ([]Tool, error) {
 	ts, err := a.s.ListTools(ctx, status)
 	if err != nil {
@@ -801,6 +805,13 @@ func (s *Server) dispatch(ctx context.Context, req Request) (json.RawMessage, er
 		}
 		return marshalResult(t), nil
 
+	case MethodMorningStatus:
+		s, err := api.MorningStatus(ctx)
+		if err != nil {
+			return nil, err
+		}
+		return marshalResult(s), nil
+
 	case MethodAssertStepUp:
 		if s.StepUp != nil {
 			return marshalResult(nil), s.StepUp(ctx)

internal/ipc/wire.go

@@ -43,6 +43,7 @@ const (
 	MethodDismissProposedRoutine Method = "dismiss_proposed_routine"
 	MethodRevertFact             Method = "revert_fact"
 	MethodTickTrace          Method = "tick_trace"
+	MethodMorningStatus      Method = "morning_status"
 	MethodChat               Method = "chat"
 )