{{.Name}}
{{if .Active}}active now{{else}}outside window{{end}}
diff --git a/internal/ipc/api.go b/internal/ipc/api.go
index 6f879b8..fe779e4 100644
--- a/internal/ipc/api.go
+++ b/internal/ipc/api.go
@@ -306,6 +306,14 @@ type CoreAPI interface {
// TickTrace.
MorningStatus(ctx context.Context) ([]MorningRoutineStatus, error)
+ // DayPlan returns today's ordered plan — calendar events, pending
+ // reminders and any morning checklist still outstanding (see
+ // internal/morning.BuildPlan) — plus the spoken RU rendering of it.
+ // Read-only: asking for the plan never dispatches or schedules anything.
+ // The store adapter returns an error (the plan needs the daemon's routine
+ // config) — same shape as TickTrace and MorningStatus.
+ DayPlan(ctx context.Context) (DayPlan, 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).
@@ -359,6 +367,26 @@ type MorningRoutineStatus struct {
Items []MorningRoutineItem `json:"items"`
}
+// DayPlanItem — one line of the day plan. Kind is "event", "reminder" or
+// "checklist"; Uncertain marks an item whose provenance is below a full
+// calendar read (a meeting relayed off a phone notification), so a UI can hedge
+// the same way the spoken form does.
+type DayPlanItem struct {
+ At time.Time `json:"at"`
+ Text string `json:"text"`
+ Kind string `json:"kind"`
+ Uncertain bool `json:"uncertain,omitempty"`
+}
+
+// DayPlan — the plan for one calendar day. Spoken is the RU sentence maven
+// says when asked, rendered core-side so the voice reply and the web view can
+// never drift apart.
+type DayPlan struct {
+ Date time.Time `json:"date"`
+ Items []DayPlanItem `json:"items"`
+ Spoken string `json:"spoken"`
+}
+
// storeEncryptionKeyReq — passkey credential public key for wrapping the store
// encryption key at enrollment time. Called by mavweb after RegisterFinish.
type storeEncryptionKeyReq struct {
diff --git a/internal/ipc/client.go b/internal/ipc/client.go
index 208c250..5717ee1 100644
--- a/internal/ipc/client.go
+++ b/internal/ipc/client.go
@@ -71,6 +71,7 @@ var readOnlyMethods = map[Method]bool{
MethodListProposedRoutines: true,
MethodTickTrace: true,
MethodMorningStatus: true,
+ MethodDayPlan: true,
}
// Dial connects to a core socket at path and returns a Client. The module
@@ -458,6 +459,14 @@ func (c *Client) MorningStatus(ctx context.Context) ([]MorningRoutineStatus, err
return s, nil
}
+func (c *Client) DayPlan(ctx context.Context) (DayPlan, error) {
+ var p DayPlan
+ if err := c.call(ctx, MethodDayPlan, nil, &p); err != nil {
+ return DayPlan{}, err
+ }
+ return p, nil
+}
+
func (c *Client) RevertFact(ctx context.Context, key string) (int64, error) {
var result struct {
NewID int64 `json:"new_id"`
diff --git a/internal/ipc/server.go b/internal/ipc/server.go
index 91e4bc1..21fbb1f 100644
--- a/internal/ipc/server.go
+++ b/internal/ipc/server.go
@@ -211,6 +211,10 @@ func (a *storeAPI) MorningStatus(ctx context.Context) ([]MorningRoutineStatus, e
return nil, errors.New("store: morning status not available via direct store API")
}
+func (a *storeAPI) DayPlan(ctx context.Context) (DayPlan, error) {
+ return DayPlan{}, errors.New("store: day plan 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 {
@@ -729,6 +733,9 @@ var methodTable = map[Method]handlerFunc{
// MorningStatus intentionally has no nil→[]T{} normalization here — the
// pre-table arm marshaled api.MorningStatus's result as-is (a nil slice
// serializes as JSON null), and this preserves that exact wire shape.
+ MethodDayPlan: withoutParams(func(ctx context.Context, api CoreAPI) (DayPlan, error) {
+ return api.DayPlan(ctx)
+ }),
MethodMorningStatus: withoutParams(func(ctx context.Context, api CoreAPI) ([]MorningRoutineStatus, error) {
return api.MorningStatus(ctx)
}),
diff --git a/internal/ipc/unimplemented.go b/internal/ipc/unimplemented.go
index 5407f96..daef767 100644
--- a/internal/ipc/unimplemented.go
+++ b/internal/ipc/unimplemented.go
@@ -113,6 +113,9 @@ func (UnimplementedCoreAPI) TickTrace(ctx context.Context) (TickTrace, error) {
func (UnimplementedCoreAPI) MorningStatus(ctx context.Context) ([]MorningRoutineStatus, error) {
return nil, ErrNotImplemented
}
+func (UnimplementedCoreAPI) DayPlan(ctx context.Context) (DayPlan, error) {
+ return DayPlan{}, ErrNotImplemented
+}
func (UnimplementedCoreAPI) Chat(ctx context.Context, text string) (string, error) {
return "", ErrNotImplemented
}
diff --git a/internal/ipc/wire.go b/internal/ipc/wire.go
index c67cec1..e1c4dad 100644
--- a/internal/ipc/wire.go
+++ b/internal/ipc/wire.go
@@ -45,6 +45,7 @@ const (
MethodRevertFact Method = "revert_fact"
MethodTickTrace Method = "tick_trace"
MethodMorningStatus Method = "morning_status"
+ MethodDayPlan Method = "day_plan"
MethodChat Method = "chat"
)
diff --git a/internal/morning/plan.go b/internal/morning/plan.go
new file mode 100644
index 0000000..530a33a
--- /dev/null
+++ b/internal/morning/plan.go
@@ -0,0 +1,165 @@
+package morning
+
+import (
+ "fmt"
+ "sort"
+ "strings"
+ "time"
+
+ "github.com/kami/maven/internal/store"
+)
+
+// The day plan (Vikunja #128).
+//
+// It lives here, with the morning routine engine, because it is the same
+// question asked at a different scale: the routine knows what is still missing
+// from a window, the plan knows what the whole day holds. A parallel system
+// would have to re-read the same facts and re-decide what "today" means.
+//
+// It is pure, like the rest of this package: the daemon reads the calendar,
+// the reminders and the checklist facts, and BuildPlan puts them in order.
+//
+// It is also NOT a nag. A plan she can recite when asked is the whole feature;
+// nothing here fires, schedules or announces. Unprompted delivery stays with
+// the existing morning nudge and the dispatcher's policy.
+
+// PlanKind — where a plan line came from. It survives into the reply and the
+// web view because the three read differently: an event is something happening
+// to the owner, a reminder is something he asked for, a checklist item is
+// something he has not done yet.
+type PlanKind string
+
+const (
+ PlanEvent PlanKind = "event"
+ PlanReminder PlanKind = "reminder"
+ PlanChecklist PlanKind = "checklist"
+)
+
+// PlanEntry — one timed thing on the day, as the daemon read it out of the
+// store. Text is rendered verbatim; the plan does not rephrase.
+//
+// Uncertain marks provenance below a full-confidence read — a work meeting
+// relayed off a phone notification (#126). It travels through to the reply so
+// she hedges instead of reciting a guess as fact.
+type PlanEntry struct {
+ At time.Time
+ Text string
+ Kind PlanKind
+ Uncertain bool
+}
+
+// Plan — the ordered day. Date is the calendar day it describes.
+type Plan struct {
+ Date time.Time
+ Items []PlanEntry
+}
+
+// BuildPlan orders everything known about the day Now falls on: calendar
+// events, pending reminders, and one line per morning routine that still has
+// unfinished items.
+//
+// Entries outside that calendar day are dropped — a plan for today that
+// includes tomorrow's meeting is wrong in a way that is worse than terse.
+// Ordering is by time, then by kind, then by text, so the same day always reads
+// the same way.
+func BuildPlan(routines []Routine, facts map[string]store.Fact, events, reminders []PlanEntry, now time.Time) Plan {
+ y, m, d := now.Date()
+ dayStart := time.Date(y, m, d, 0, 0, 0, 0, now.Location())
+ dayEnd := dayStart.AddDate(0, 0, 1)
+
+ p := Plan{Date: dayStart}
+ for _, group := range [][]PlanEntry{events, reminders} {
+ for _, e := range group {
+ at := e.At.In(now.Location())
+ if at.Before(dayStart) || !at.Before(dayEnd) {
+ continue
+ }
+ if strings.TrimSpace(e.Text) == "" {
+ continue
+ }
+ e.At = at
+ p.Items = append(p.Items, e)
+ }
+ }
+ p.Items = append(p.Items, checklistEntries(routines, facts, now)...)
+
+ sort.SliceStable(p.Items, func(i, j int) bool {
+ a, b := p.Items[i], p.Items[j]
+ if !a.At.Equal(b.At) {
+ return a.At.Before(b.At)
+ }
+ if a.Kind != b.Kind {
+ return a.Kind < b.Kind
+ }
+ return a.Text < b.Text
+ })
+ return p
+}
+
+// checklistEntries renders one line per routine with work left in it, placed at
+// the routine's nudge time — where the checklist actually matters in the day.
+// A routine that does not apply today, is not in its window, or is already
+// complete contributes nothing: the plan says what is left, not what was done.
+func checklistEntries(routines []Routine, facts map[string]store.Fact, now time.Time) []PlanEntry {
+ var out []PlanEntry
+ for _, r := range routines {
+ st := Evaluate(r, facts, now)
+ if !st.Active || len(st.Missing) == 0 {
+ continue
+ }
+ labels := make([]string, 0, len(st.Missing))
+ for _, it := range st.Missing {
+ label := it.Label
+ if label == "" {
+ label = it.Key
+ }
+ labels = append(labels, label)
+ }
+ at := r.NudgeAt
+ if at == "" {
+ at = r.WindowEnd
+ }
+ when, ok := todayAt(at, now)
+ if !ok {
+ continue
+ }
+ out = append(out, PlanEntry{
+ At: when,
+ Text: fmt.Sprintf("%s — осталось: %s", r.Name, strings.Join(labels, ", ")),
+ Kind: PlanChecklist,
+ })
+ }
+ return out
+}
+
+// After returns the part of the plan that has not happened yet — the answer to
+// "что дальше?" as opposed to "какие планы на сегодня?". The Date is kept, so an
+// empty result still knows which day it is empty for.
+func (p Plan) After(now time.Time) Plan {
+ out := Plan{Date: p.Date}
+ for _, it := range p.Items {
+ if it.At.Before(now) {
+ continue
+ }
+ out.Items = append(out.Items, it)
+ }
+ return out
+}
+
+// FormatRU renders the plan as maven says it. Feminine self-reference,
+// informal address, no pet names — and no exhortation: she reads the day back,
+// she does not tell him to get on with it.
+func (p Plan) FormatRU() string {
+ if len(p.Items) == 0 {
+ return fmt.Sprintf("на %s ничего не запланировано.", p.Date.Format("02.01.2006"))
+ }
+ parts := make([]string, len(p.Items))
+ for i, it := range p.Items {
+ line := fmt.Sprintf("%s — %s", it.At.Format("15:04"), it.Text)
+ if it.Uncertain {
+ line = "похоже, " + line
+ }
+ parts[i] = line
+ }
+ return fmt.Sprintf("план на %s: %s.", p.Date.Format("02.01.2006"), strings.Join(parts, "; "))
+}
diff --git a/internal/morning/plan_test.go b/internal/morning/plan_test.go
new file mode 100644
index 0000000..35ff4d1
--- /dev/null
+++ b/internal/morning/plan_test.go
@@ -0,0 +1,169 @@
+package morning
+
+import (
+ "strings"
+ "testing"
+ "time"
+
+ "github.com/kami/maven/internal/store"
+)
+
+// planAt is at() for the plan tests' day (2026-08-03, a Monday); the existing
+// at() in morning_test.go is pinned to a different date.
+func planAt(now time.Time, hh, mm int) time.Time {
+ y, m, d := now.Date()
+ return time.Date(y, m, d, hh, mm, 0, 0, now.Location())
+}
+
+func planFixture(t *testing.T) (Plan, time.Time) {
+ t.Helper()
+ now := time.Date(2026, 8, 3, 9, 0, 0, 0, time.UTC)
+ routines := []Routine{{
+ Name: "утро",
+ WindowStart: "07:00",
+ WindowEnd: "11:00",
+ NudgeAt: "10:30",
+ Items: []Item{
+ {Key: "water", FactKey: "drank_water", Label: "выпить воды"},
+ {Key: "pills", FactKey: "took_pills", Label: "витамины"},
+ },
+ }}
+ facts := map[string]store.Fact{
+ "drank_water": {Ts: planAt(now, 8, 0)},
+ }
+ events := []PlanEntry{
+ {At: planAt(now, 14, 0), Text: "Планёрка @ 14:00-14:30", Kind: PlanEvent, Uncertain: true},
+ {At: planAt(now, 10, 0), Text: "Standup @ 10:00-10:30", Kind: PlanEvent},
+ }
+ reminders := []PlanEntry{
+ {At: planAt(now, 18, 30), Text: "позвонить маме", Kind: PlanReminder},
+ }
+ return BuildPlan(routines, facts, events, reminders, now), now
+}
+
+func TestBuildPlanOrdersTheDay(t *testing.T) {
+ p, now := planFixture(t)
+
+ if !p.Date.Equal(planAt(now, 0, 0)) {
+ t.Errorf("Date = %v, want midnight of now's day", p.Date)
+ }
+ want := []struct {
+ hhmm string
+ kind PlanKind
+ }{
+ {"10:00", PlanEvent},
+ {"10:30", PlanChecklist},
+ {"14:00", PlanEvent},
+ {"18:30", PlanReminder},
+ }
+ if len(p.Items) != len(want) {
+ t.Fatalf("got %d items, want %d: %+v", len(p.Items), len(want), p.Items)
+ }
+ for i, w := range want {
+ if got := p.Items[i].At.Format("15:04"); got != w.hhmm {
+ t.Errorf("item %d at %s, want %s", i, got, w.hhmm)
+ }
+ if p.Items[i].Kind != w.kind {
+ t.Errorf("item %d kind %q, want %q", i, p.Items[i].Kind, w.kind)
+ }
+ }
+}
+
+// The checklist line says what is LEFT. An item already evidenced today must
+// not be read back as outstanding.
+func TestBuildPlanChecklistListsOnlyMissing(t *testing.T) {
+ p, _ := planFixture(t)
+ var line string
+ for _, it := range p.Items {
+ if it.Kind == PlanChecklist {
+ line = it.Text
+ }
+ }
+ if line == "" {
+ t.Fatal("no checklist line in the plan")
+ }
+ if !strings.Contains(line, "витамины") {
+ t.Errorf("missing item not listed: %q", line)
+ }
+ if strings.Contains(line, "выпить воды") {
+ t.Errorf("a completed item must not be read back as outstanding: %q", line)
+ }
+ if !strings.HasPrefix(line, "утро — осталось:") {
+ t.Errorf("line = %q", line)
+ }
+}
+
+func TestBuildPlanSkipsCompleteAndInactiveRoutines(t *testing.T) {
+ now := time.Date(2026, 8, 3, 9, 0, 0, 0, time.UTC)
+ routines := []Routine{
+ {
+ Name: "утро", WindowStart: "07:00", WindowEnd: "11:00",
+ Items: []Item{{Key: "water", FactKey: "drank_water", Label: "выпить воды"}},
+ },
+ {
+ // Not in its window at 09:00.
+ Name: "вечер", WindowStart: "20:00", WindowEnd: "23:00",
+ Items: []Item{{Key: "walk", FactKey: "walked", Label: "прогулка"}},
+ },
+ }
+ facts := map[string]store.Fact{"drank_water": {Ts: planAt(now, 8, 0)}}
+ p := BuildPlan(routines, facts, nil, nil, now)
+ if len(p.Items) != 0 {
+ t.Fatalf("a complete routine and an out-of-window one must contribute nothing: %+v", p.Items)
+ }
+ if got, want := p.FormatRU(), "на 03.08.2026 ничего не запланировано."; got != want {
+ t.Errorf("got %q\nwant %q", got, want)
+ }
+}
+
+// A plan for today that includes tomorrow's meeting is worse than terse.
+func TestBuildPlanDropsOtherDays(t *testing.T) {
+ now := time.Date(2026, 8, 3, 9, 0, 0, 0, time.UTC)
+ events := []PlanEntry{
+ {At: planAt(now, 10, 0), Text: "today", Kind: PlanEvent},
+ {At: planAt(now, 10, 0).AddDate(0, 0, 1), Text: "tomorrow", Kind: PlanEvent},
+ {At: planAt(now, 10, 0).AddDate(0, 0, -1), Text: "yesterday", Kind: PlanEvent},
+ {At: planAt(now, 12, 0), Text: " ", Kind: PlanEvent},
+ }
+ p := BuildPlan(nil, nil, events, nil, now)
+ if len(p.Items) != 1 || p.Items[0].Text != "today" {
+ t.Fatalf("got %+v", p.Items)
+ }
+}
+
+func TestPlanFormatRU(t *testing.T) {
+ p, _ := planFixture(t)
+ got := p.FormatRU()
+ want := "план на 03.08.2026: 10:00 — Standup @ 10:00-10:30; " +
+ "10:30 — утро — осталось: витамины; " +
+ "похоже, 14:00 — Планёрка @ 14:00-14:30; " +
+ "18:30 — позвонить маме."
+ if got != want {
+ t.Errorf("got %q\nwant %q", got, want)
+ }
+ // Persona: she recites, she does not exhort, and she never speaks of
+ // herself in the masculine or addresses him formally.
+ for _, bad := range []string{"рад ", "понял", "вы ", "ваш", "милый", "дорогой", "давай же", "не забудь"} {
+ if strings.Contains(strings.ToLower(got), bad) {
+ t.Errorf("plan text contains %q: %q", bad, got)
+ }
+ }
+}
+
+func TestPlanAfter(t *testing.T) {
+ p, now := planFixture(t)
+ rest := p.After(planAt(now, 11, 0))
+ if len(rest.Items) != 2 {
+ t.Fatalf("got %d items, want the 14:00 and 18:30 ones: %+v", len(rest.Items), rest.Items)
+ }
+ if !rest.Date.Equal(p.Date) {
+ t.Error("After must keep the date, so an empty rest-of-day still knows which day")
+ }
+ empty := p.After(planAt(now, 23, 0))
+ if len(empty.Items) != 0 {
+ t.Errorf("got %+v", empty.Items)
+ }
+ if !strings.Contains(empty.FormatRU(), "ничего не запланировано") {
+ t.Errorf("empty plan reads %q", empty.FormatRU())
+ }
+}
diff --git a/internal/router/calendar.go b/internal/router/calendar.go
index 6188672..3f86976 100644
--- a/internal/router/calendar.go
+++ b/internal/router/calendar.go
@@ -4,6 +4,7 @@ import (
"fmt"
"strings"
"time"
+ "unicode"
)
// CalendarEventFormatter formats calendar events into a Russian reply string.
@@ -18,6 +19,71 @@ type CalendarEntry struct {
Uncertain bool
}
+// dayPlanWords — the tokens that ask for the day as a whole rather than for a
+// calendar listing. Whole words, not substrings: "планёрка" is a MEETING, and a
+// notification about one must not be mistaken for a request for the plan.
+var dayPlanWords = []string{
+ "план", "плана", "плану", "плане", "планом",
+ "планы", "планов", "планам", "планах",
+ "расписание", "расписании", "распорядок", "распорядке",
+ "plan", "plans", "schedule", "agenda",
+}
+
+// otherDayWords — a day that is not today. The plan is built for the clock's
+// own day only, so an utterance naming another one belongs to the calendar
+// listing instead. Claiming it here would answer the wrong day, which is worse
+// than answering more tersely.
+var otherDayWords = []string{
+ "завтра", "послезавтра", "вчера", "позавчера",
+ "tomorrow", "yesterday",
+}
+
+// IsDayPlanQuery reports whether an utterance asks for today's plan (Vikunja
+// #128) — "какие планы на сегодня?", "что у меня по плану?", "что дальше?".
+//
+// Deliberately narrow. The calendar listing already answers "что у меня
+// сегодня?" and a plan that hijacks every date-bearing question would bury the
+// events under checklist lines. Only a plan-shaped ask, and only about today.
+func IsDayPlanQuery(text string) bool {
+ toks := planTokens(text)
+ for _, t := range toks {
+ for _, w := range otherDayWords {
+ if t == w {
+ return false
+ }
+ }
+ }
+ for _, t := range toks {
+ for _, w := range dayPlanWords {
+ if t == w {
+ return true
+ }
+ }
+ }
+ // "что дальше?" / "what's next?" — the rest of the day, with no plan word
+ // in it. Both tokens rather than adjacency, because "what's" splits into
+ // "what" and "s" and because "и что потом дальше" is the same question.
+ return (hasTok(toks, "что") && hasTok(toks, "дальше")) ||
+ (hasTok(toks, "what") && hasTok(toks, "next"))
+}
+
+func hasTok(toks []string, w string) bool {
+ for _, t := range toks {
+ if t == w {
+ return true
+ }
+ }
+ return false
+}
+
+// planTokens lowercases and splits on everything that is not a letter or a
+// digit, so "планы?" and "что-дальше" tokenize like the plain words do.
+func planTokens(text string) []string {
+ return strings.FieldsFunc(strings.ToLower(text), func(r rune) bool {
+ return !unicode.IsLetter(r) && !unicode.IsDigit(r)
+ })
+}
+
// Format returns a Russian reply for the given calendar events on the given
// date. Every event is treated as certain — use FormatEntries when provenance
// differs between them.
diff --git a/internal/router/calendar_test.go b/internal/router/calendar_test.go
index b955560..4772733 100644
--- a/internal/router/calendar_test.go
+++ b/internal/router/calendar_test.go
@@ -45,3 +45,39 @@ func TestCalendarEventFormatterHedgesUncertainEntries(t *testing.T) {
t.Errorf("empty: got %q", got)
}
}
+
+func TestIsDayPlanQuery(t *testing.T) {
+ yes := []string{
+ "какие планы на сегодня?",
+ "что у меня по плану",
+ "расскажи план",
+ "мой распорядок на сегодня",
+ "расписание?",
+ "что дальше?",
+ "what's next",
+ "what is my plan today",
+ }
+ for _, s := range yes {
+ if !IsDayPlanQuery(s) {
+ t.Errorf("IsDayPlanQuery(%q) = false, want true", s)
+ }
+ }
+
+ no := []string{
+ // The calendar listing owns these.
+ "что у меня сегодня?",
+ "какие планы на завтра?",
+ "план на послезавтра",
+ "что было вчера",
+ // "планёрка" is a meeting, not a request for the plan.
+ "когда планёрка?",
+ "запиши планёрку на 14:00",
+ "какая погода?",
+ "",
+ }
+ for _, s := range no {
+ if IsDayPlanQuery(s) {
+ t.Errorf("IsDayPlanQuery(%q) = true, want false", s)
+ }
+ }
+}