feat(storage): emit state_change events on task transitions

UpdateTaskState now writes a state_change event in the same transaction
as the row update, so the event stream and task state never diverge.
Adds UpdateTaskStateBy(id, newState, actor) for explicit actor
attribution; UpdateTaskState delegates with ActorSystem (correct for the
executor, which drives the state machine). RejectTask and
ResetTaskForRetry also emit state_change events attributed to the user.

API accept and cancel handlers now attribute their transitions to the
user via UpdateTaskStateBy. The executor's Store interface is unchanged,
so no test doubles needed updating.

https://claude.ai/code/session_01SESwn7kQ7oP62trWw6pc39

1 files changed, 106 insertions, 0 deletions

diff --git a/internal/storage/events_test.go b/internal/storage/events_test.go
index 3b342c7..1f03aeb 100644
--- a/internal/storage/events_test.go
+++ b/internal/storage/events_test.go
@@ -160,6 +160,112 @@ func TestListEvents_PreservesPayloadAndKind(t *testing.T) {
 	}
 }
 
+func TestUpdateTaskState_WritesStateChangeEvent(t *testing.T) {
+	db := testDB(t)
+	makeTaskForEvent(t, db, "task-1") // starts PENDING
+
+	if err := db.UpdateTaskState("task-1", task.StateQueued); err != nil {
+		t.Fatalf("UpdateTaskState: %v", err)
+	}
+
+	events, err := db.ListEvents("task-1", 0)
+	if err != nil {
+		t.Fatalf("ListEvents: %v", err)
+	}
+	if len(events) != 1 {
+		t.Fatalf("expected 1 event, got %d", len(events))
+	}
+	e := events[0]
+	if e.Kind != event.KindStateChange {
+		t.Errorf("kind: got %v want state_change", e.Kind)
+	}
+	if e.Actor != event.ActorSystem {
+		t.Errorf("actor: got %v want system", e.Actor)
+	}
+	var payload struct {
+		From task.State `json:"from"`
+		To   task.State `json:"to"`
+	}
+	if err := json.Unmarshal(e.Payload, &payload); err != nil {
+		t.Fatalf("unmarshal payload: %v", err)
+	}
+	if payload.From != task.StatePending || payload.To != task.StateQueued {
+		t.Errorf("payload: got %s→%s want PENDING→QUEUED", payload.From, payload.To)
+	}
+}
+
+func TestUpdateTaskStateBy_AttributesActor(t *testing.T) {
+	db := testDB(t)
+	makeTaskForEvent(t, db, "task-1")
+
+	if err := db.UpdateTaskStateBy("task-1", task.StateCancelled, event.ActorUser); err != nil {
+		t.Fatalf("UpdateTaskStateBy: %v", err)
+	}
+
+	events, err := db.ListEvents("task-1", 0)
+	if err != nil {
+		t.Fatalf("ListEvents: %v", err)
+	}
+	if len(events) != 1 {
+		t.Fatalf("expected 1 event, got %d", len(events))
+	}
+	if events[0].Actor != event.ActorUser {
+		t.Errorf("actor: got %v want user", events[0].Actor)
+	}
+}
+
+func TestUpdateTaskState_InvalidTransition_WritesNoEvent(t *testing.T) {
+	db := testDB(t)
+	makeTaskForEvent(t, db, "task-1") // PENDING
+
+	// PENDING → COMPLETED is not a valid transition.
+	if err := db.UpdateTaskState("task-1", task.StateCompleted); err == nil {
+		t.Fatal("expected invalid transition error, got nil")
+	}
+
+	events, err := db.ListEvents("task-1", 0)
+	if err != nil {
+		t.Fatalf("ListEvents: %v", err)
+	}
+	if len(events) != 0 {
+		t.Fatalf("expected no events after rejected transition, got %d", len(events))
+	}
+}
+
+func TestRejectTask_WritesUserStateChangeEvent(t *testing.T) {
+	db := testDB(t)
+	makeTaskForEvent(t, db, "task-1")
+	// Drive PENDING → QUEUED → RUNNING → READY so reject is valid.
+	for _, st := range []task.State{task.StateQueued, task.StateRunning, task.StateReady} {
+		if err := db.UpdateTaskState("task-1", st); err != nil {
+			t.Fatalf("transition to %s: %v", st, err)
+		}
+	}
+
+	if err := db.RejectTask("task-1", "needs work"); err != nil {
+		t.Fatalf("RejectTask: %v", err)
+	}
+
+	events, err := db.ListEvents("task-1", 0)
+	if err != nil {
+		t.Fatalf("ListEvents: %v", err)
+	}
+	last := events[len(events)-1]
+	if last.Kind != event.KindStateChange || last.Actor != event.ActorUser {
+		t.Errorf("reject event: got kind=%v actor=%v want state_change/user", last.Kind, last.Actor)
+	}
+	var payload struct {
+		From task.State `json:"from"`
+		To   task.State `json:"to"`
+	}
+	if err := json.Unmarshal(last.Payload, &payload); err != nil {
+		t.Fatalf("unmarshal: %v", err)
+	}
+	if payload.From != task.StateReady || payload.To != task.StatePending {
+		t.Errorf("payload: got %s→%s want READY→PENDING", payload.From, payload.To)
+	}
+}
+
 func TestCreateEvent_RequiresFields(t *testing.T) {
 	db := testDB(t)