a live task can be edited, a resolved one cannot (V-509)

SetTaskStatus was the only mutation on a task row, so a typo in a dictated
task was permanent and a deadline could not move. EditTask rewrites the three
fields capture set — text, due date and weight — and nothing else. Status
stays the one-way ladder SetTaskStatus owns.

Two things the task asked to settle.

A text edit re-normalises the dedupe key and can collide with another live
row. That is ErrTaskDuplicate, a refusal rather than a merge: two live rows
carry two provenances, two capture times and possibly two external
identities, and merging picks a winner for all three with nobody asked. The
surface names the row that holds the text.

A resolved task is refused outright (ErrTaskResolved). Its text is the record
of what was finished, and rewriting it rewrites history.

due nil clears the date, because clearing has to be sayable — an absent date
and "remove the date" cannot be one argument.

internal/store/tasks.go

@@ -98,6 +98,16 @@ var (
 	// finish line nobody wrote is how a board fills with rows that can never
 	// leave it. Dropping such a candidate stays legal.
 	ErrTaskNoDoneWhen = errors.New("store: task has no definition of done")
+	// ErrTaskDuplicate — an edit would give this task the normalised text of
+	// another live row (Vikunja #509). A refusal, not a merge: two live rows
+	// carry two provenances, two capture times and possibly two external
+	// identities, and merging picks a winner for all three silently. The
+	// surface tells the owner which row already holds the text and lets him
+	// drop one.
+	ErrTaskDuplicate = errors.New("store: another live task already has this text")
+	// ErrTaskResolved — a resolved task is not editable. Its text is the
+	// record of what was finished, and rewriting it rewrites history.
+	ErrTaskResolved = errors.New("store: task is resolved")
 )
 
 // liveTaskStatuses — the two statuses that count as outstanding work.
@@ -381,6 +391,50 @@ func (s *Store) setTaskStatus(ctx context.Context, id int64, status string, ts t
 	return nil
 }
 
+// EditTask rewrites the three fields capture set and nothing else: text, due
+// date and weight (Vikunja #509). Status stays the one-way ladder SetTaskStatus
+// owns, and a resolved task is refused outright — its text is the record of
+// what was finished.
+//
+// Editing text re-normalises the dedupe key, which can collide with another
+// live row. That is ErrTaskDuplicate and it is a refusal: merging would pick
+// one row's provenance, capture time and external identity over the other's
+// with nobody asked.
+//
+// due nil clears the date. Clearing has to be sayable, so an absent date and
+// "remove the date" cannot be the same argument.
+func (s *Store) EditTask(ctx context.Context, id int64, text string, due *time.Time, weight int) error {
+	text = strings.TrimSpace(text)
+	if text == "" {
+		return ErrTaskEmpty
+	}
+	cur, err := s.LookupTask(ctx, id)
+	if err != nil {
+		return err
+	}
+	if cur.Status != TaskCandidate && cur.Status != TaskOpen {
+		return fmt.Errorf("%w: id=%d is %s", ErrTaskResolved, id, cur.Status)
+	}
+	norm := NormalizeTaskText(text)
+	if norm != NormalizeTaskText(cur.Text) {
+		if other, err := s.lookupLiveTaskByNorm(ctx, norm); err == nil && other.ID != id {
+			return fmt.Errorf("%w: id=%d holds it", ErrTaskDuplicate, other.ID)
+		} else if err != nil && !errors.Is(err, ErrTaskNotFound) {
+			return err
+		}
+	}
+	var dueVal sql.NullInt64
+	if due != nil {
+		dueVal = sql.NullInt64{Int64: due.UnixMilli(), Valid: true}
+	}
+	if _, err := s.db.ExecContext(ctx,
+		`UPDATE tasks SET text = ?, norm = ?, due_ts = ?, weight = ? WHERE id = ?`,
+		text, norm, dueVal, weight, id); err != nil {
+		return fmt.Errorf("edit task: %w", err)
+	}
+	return nil
+}
+
 // SetTaskFields writes the two board columns. Separate from SetTaskStatus
 // because a status move is one-way and these are not: he may sharpen a
 // definition of done, and a blocker clears when the person answers.

internal/store/tasks_test.go

@@ -465,3 +465,80 @@ func TestPromotingACandidateNeedsADefinitionOfDone(t *testing.T) {
 		t.Errorf("status = %q, want open", got.Status)
 	}
 }
+
+func TestEditTaskRewritesTheCaptureFields(t *testing.T) {
+	ctx := context.Background()
+	st := newTestStore(t)
+	now := time.Date(2026, 8, 5, 9, 0, 0, 0, time.UTC)
+	due := now.Add(48 * time.Hour)
+
+	res, err := st.CaptureTask(ctx, Task{Text: "купить малако", Source: "tap:voice", CreatedTs: now, Weight: 1})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := st.EditTask(ctx, res.ID, "  купить молоко  ", &due, 3); err != nil {
+		t.Fatal(err)
+	}
+	got, err := st.LookupTask(ctx, res.ID)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got.Text != "купить молоко" || got.Weight != 3 || got.Due == nil || !got.Due.Equal(due) {
+		t.Fatalf("task = %+v, want the dictation typo fixed with the date and weight", got)
+	}
+	// Clearing the date has to be sayable, or an absent date and "remove the
+	// date" would be one argument.
+	if err := st.EditTask(ctx, res.ID, "купить молоко", nil, 3); err != nil {
+		t.Fatal(err)
+	}
+	if got, err = st.LookupTask(ctx, res.ID); err != nil {
+		t.Fatal(err)
+	} else if got.Due != nil {
+		t.Errorf("due = %v, want it cleared", got.Due)
+	}
+	// The dedupe key moved with the text: capturing the old wording is new work.
+	again, err := st.CaptureTask(ctx, Task{Text: "купить малако", Source: "tap:voice", CreatedTs: now})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !again.Created {
+		t.Error("the old normalised text must be free after the edit")
+	}
+	if err := st.EditTask(ctx, res.ID, "", nil, 0); !errors.Is(err, ErrTaskEmpty) {
+		t.Errorf("empty text = %v, want ErrTaskEmpty", err)
+	}
+}
+
+func TestEditTaskRefusesACollisionAndAResolvedRow(t *testing.T) {
+	ctx := context.Background()
+	st := newTestStore(t)
+	now := time.Date(2026, 8, 5, 9, 0, 0, 0, time.UTC)
+
+	first, err := st.CaptureTask(ctx, Task{Text: "купить молоко", Source: "tap:voice", CreatedTs: now})
+	if err != nil {
+		t.Fatal(err)
+	}
+	second, err := st.CaptureTask(ctx, Task{Text: "оплатить интернет", Source: "tap:voice", CreatedTs: now})
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Two live rows carry two provenances and two capture times, so a merge
+	// would pick a winner for both with nobody asked.
+	if err := st.EditTask(ctx, second.ID, "Купить молоко!", nil, 0); !errors.Is(err, ErrTaskDuplicate) {
+		t.Errorf("collision = %v, want ErrTaskDuplicate", err)
+	}
+	// Editing a row to the text it already has is not a collision with itself.
+	if err := st.EditTask(ctx, first.ID, "купить молоко", nil, 2); err != nil {
+		t.Errorf("re-saving the same text: %v", err)
+	}
+	if err := st.SetTaskStatus(ctx, first.ID, TaskDone, now.Add(time.Hour), "tap:web"); err != nil {
+		t.Fatal(err)
+	}
+	// A resolved task's text is the record of what was finished.
+	if err := st.EditTask(ctx, first.ID, "купить кефир", nil, 0); !errors.Is(err, ErrTaskResolved) {
+		t.Errorf("editing a resolved task = %v, want ErrTaskResolved", err)
+	}
+	if err := st.EditTask(ctx, 9999, "что-то", nil, 0); !errors.Is(err, ErrTaskNotFound) {
+		t.Errorf("editing a missing row = %v, want ErrTaskNotFound", err)
+	}
+}