Rank captured tasks by what he actually said (#129)

Ordering is computed, not generated. Asking a 1.7B which of his tasks
matters most produces a fluent opinion with no basis in anything, and a
confidently wrong priority is worse than none — same posture as the
behaviour profile in internal/memory, which counts instead of summarising.

internal/tasks is a pure package (no ipc, no store, no cgo) holding the
score, the order and the Russian rendering, so the spoken list and the
/tasks page cannot drift. Four signals, all of them things he stated:
deadline (overdue > today > tomorrow > this week), stated urgency, age
with a cap so nothing rots at the bottom, and confirmed work always
ahead of mail-derived candidates. A task with no due date and no weight
scores nothing and carries no reason string — inventing a "потому что"
about a priority he never set is the failure mode this avoids.

Capture now picks up urgency he says out loud ("добавь в задачи срочно
оплатить интернет"), stripping the marker from the task text, and the web
add form offers the same three rungs. Ranking is a read: it sorts and
renders, never writes, schedules or announces.

cmd/mavend/actions_task.go

@@ -3,11 +3,11 @@ package main
 import (
 	"context"
 	"log"
-	"strings"
 
 	"github.com/kami/maven/internal/ipc"
 	"github.com/kami/maven/internal/router"
 	"github.com/kami/maven/internal/store"
+	"github.com/kami/maven/internal/tasks"
 )
 
 // Task capture on the voice/chat path (Vikunja #130).
@@ -27,14 +27,15 @@ import (
 // captureTaskFromNote claims the turn when the utterance explicitly files a
 // task, returning the reply. ("", false) hands the turn back to the note path.
 func (h *reactiveHandler) captureTaskFromNote(ctx context.Context, dec router.Decision) (string, bool) {
-	text, ok := router.ParseTaskCapture(dec.Utterance)
+	cap, ok := router.ParseTaskCapture(dec.Utterance)
 	if !ok {
 		return "", false
 	}
 	resp, err := h.api.CaptureTask(ctx, ipc.CaptureTaskReq{
-		Text:   text,
+		Text:   cap.Text,
 		Source: "tap:voice",
 		Status: store.TaskOpen, // he stated it himself — not a candidate
+		Weight: cap.Weight,     // 0 unless he said "срочно" / "важно"
 		Ts:     h.now(),
 	})
 	if err != nil {
@@ -44,56 +45,39 @@ func (h *reactiveHandler) captureTaskFromNote(ctx context.Context, dec router.De
 	if !resp.Created {
 		return "это уже в списке.", true
 	}
-	return "записала: " + text, true
+	return "записала: " + cap.Text, true
 }
 
 // queryTasks — "какие у меня задачи?", "что мне нужно сделать?".
 //
-// Reads the live set and recites it. Newest first, which is the order the store
-// returns: this source has no opinion about which task matters more, and
-// pretending otherwise would be a guess. Ranking is Vikunja #129.
+// Reads the live set and recites it in priority order (Vikunja #129). The order
+// is computed by internal/tasks from what he told her — deadlines, the urgency
+// he stated, how long a task has been sitting — never asked of the model. The
+// rendering is the package's too, so the spoken list and the /tasks page can
+// never disagree about what comes first.
 func (h *reactiveHandler) queryTasks(ctx context.Context, t *queryTurn) (string, bool) {
 	if !router.IsTaskListQuery(t.dec.Utterance) {
 		return "", false
 	}
-	tasks, err := h.api.ListTasks(ctx, "live")
+	live, err := h.api.ListTasks(ctx, "live")
 	if err != nil {
 		log.Printf("voice: list tasks: %v", err)
 		return "не получилось посмотреть задачи.", true
 	}
-	return formatTaskListRU(tasks), true
+	return tasks.FormatRU(tasks.Rank(taskItems(live), h.now())), true
 }
 
-// formatTaskListRU renders the live task list the way Maven says it. Candidates
-// are named as candidates — a task she pulled out of his mail is something she
-// suggests, and saying it in the same breath as work he actually stated would
-// put words in his mouth.
-func formatTaskListRU(tasks []ipc.Task) string {
-	var open, cands []string
-	for _, t := range tasks {
-		switch t.Status {
-		case store.TaskCandidate:
-			cands = append(cands, t.Text)
-		default:
-			open = append(open, t.Text)
+// taskItems maps wire rows onto the ranker's input. Written here rather than in
+// internal/tasks so the ranker stays a pure package with no ipc (and therefore
+// no store, and therefore no cgo) dependency — the same posture as
+// internal/morning and internal/memory.
+func taskItems(ts []ipc.Task) []tasks.Item {
+	out := make([]tasks.Item, len(ts))
+	for i, t := range ts {
+		out[i] = tasks.Item{
+			ID: t.ID, Text: t.Text, Status: t.Status,
+			Created: t.CreatedTs, Due: t.Due, Weight: t.Weight,
 		}
 	}
-	if len(open) == 0 && len(cands) == 0 {
-		return "задач нет."
-	}
-	var b strings.Builder
-	if len(open) > 0 {
-		b.WriteString("в списке: ")
-		b.WriteString(strings.Join(open, "; "))
-		b.WriteString(".")
-	}
-	if len(cands) > 0 {
-		if b.Len() > 0 {
-			b.WriteString(" ")
-		}
-		b.WriteString("ещё я нашла, но ты не подтвердил: ")
-		b.WriteString(strings.Join(cands, "; "))
-		b.WriteString(".")
-	}
-	return b.String()
+	return out
 }

cmd/mavend/actions_task_test.go

@@ -141,6 +141,45 @@ func TestQueryTasksRecitesTheLiveList(t *testing.T) {
 	}
 }
 
+// The stated urgency rides through capture as a weight, so the ranker can use
+// it later (Vikunja #129). "срочно" is not part of the task text.
+func TestCaptureTaskCarriesStatedUrgency(t *testing.T) {
+	api := &taskAPI{created: true}
+	h := taskHandler(api)
+	if _, ok := h.captureTaskFromNote(context.Background(), router.Decision{
+		Utterance: "добавь в задачи срочно оплатить интернет",
+	}); !ok {
+		t.Fatal("expected a capture")
+	}
+	got := api.captured[0]
+	if got.Text != "оплатить интернет" {
+		t.Errorf("text = %q, want the urgency word out of the task", got.Text)
+	}
+	if got.Weight == 0 {
+		t.Error("weight = 0 — he said срочно and it was dropped")
+	}
+}
+
+// The recital is ordered by the ranker, not by insertion: a deadline he named
+// comes before undated work.
+func TestQueryTasksRecitesInPriorityOrder(t *testing.T) {
+	due := taskNow()
+	api := &taskAPI{tasks: []ipc.Task{
+		{ID: 1, Text: "купить молоко", Status: "open", CreatedTs: taskNow()},
+		{ID: 2, Text: "оплатить интернет", Status: "open", CreatedTs: taskNow(), Due: &due},
+	}}
+	h := taskHandler(api)
+	reply, _ := h.queryTasks(context.Background(), &queryTurn{
+		dec: router.Decision{Utterance: "какие у меня задачи?"},
+	})
+	if strings.Index(reply, "оплатить интернет") > strings.Index(reply, "купить молоко") {
+		t.Errorf("reply = %q, want the dated task first", reply)
+	}
+	if !strings.Contains(reply, "сегодня") {
+		t.Errorf("reply = %q, want the reason named", reply)
+	}
+}
+
 func TestQueryTasksEmptyList(t *testing.T) {
 	h := taskHandler(&taskAPI{})
 	reply, ok := h.queryTasks(context.Background(), &queryTurn{