Generalize the focus controller into a harness hosting swappable modes

Loosen AntiDrift's session controller into Keel's general collect→brain→act
loop. A new internal/harness runs at most one mode.Mode at a time, fanning
async completions out to the web SSE and status-bar surfaces.

- internal/mode: the Mode contract (Kind/Command/View/Active) plus optional
  EvidenceConsumer and Expirer ports, and the surfacing Envelope.
- internal/mode/focus: the former session/domain/statemachine packages moved
  under the mode, now satisfying the harness contracts unchanged.
- internal/mode/offscreen: a one-shot away-from-desk mode built on the new
  ai.Proposer, which turns a life-domain brief into one off-screen action.
- cmd/keeld replaces cmd/antidriftd; daemon wires focus + offscreen factories
  with per-mode persistence under ~/.keel/modes/<kind>.
- Finish the rename: KEEL_* env refs in the README, /keeld build artifact
  ignored, stale antidriftd binary removed.

Include the design + implementation plan this refactor was built from under
docs/superpowers/{specs,plans}/2026-06-04-controller-refactor*.md.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

internal/mode/offscreen/offscreen_test.go

@@ -0,0 +1,140 @@
+package offscreen
+
+import (
+	"context"
+	"errors"
+	"testing"
+	"time"
+
+	"keel/internal/ai"
+	"keel/internal/harness"
+	"keel/internal/tasks"
+)
+
+// stubBackend is a local fake ai.Backend; ai's package-internal fake is not
+// reachable from this package, so we define our own here.
+type stubBackend struct {
+	out string
+	err error
+}
+
+func (b stubBackend) Name() string { return "stub" }
+func (b stubBackend) Run(context.Context, string) (string, error) {
+	return b.out, b.err
+}
+
+type fakeTasks struct {
+	created []string
+}
+
+func (f *fakeTasks) Today(context.Context) ([]tasks.Task, error) { return nil, nil }
+func (f *fakeTasks) Create(_ context.Context, t tasks.Task) error {
+	f.created = append(f.created, t.Title)
+	return nil
+}
+
+func newTestMode(t *testing.T, ft *fakeTasks, backend ai.Backend) *Mode {
+	t.Helper()
+	svc := harness.Services{
+		AI:     ai.NewService(backend),
+		Tasks:  ft,
+		Clock:  func() time.Time { return time.Unix(0, 0) },
+		Notify: func() {},
+	}
+	return New(svc)
+}
+
+// waitStatus polls the mode's View until status reaches want, or fails after 2s.
+func waitStatus(t *testing.T, m *Mode, want string) {
+	t.Helper()
+	deadline := time.Now().Add(2 * time.Second)
+	for time.Now().Before(deadline) {
+		v, _ := m.View().(map[string]any)
+		if v != nil && v["status"] == want {
+			return
+		}
+		time.Sleep(5 * time.Millisecond)
+	}
+	t.Fatalf("status never reached %q (last view: %+v)", want, m.View())
+}
+
+func okBackend() stubBackend {
+	return stubBackend{out: `{"next_action":"call mum","rationale":"people goal"}`}
+}
+
+func TestConfirmFilesExactlyOneTask(t *testing.T) {
+	ft := &fakeTasks{}
+	m := newTestMode(t, ft, okBackend())
+	if err := m.Command(context.Background(), "start", nil); err != nil {
+		t.Fatalf("start: %v", err)
+	}
+	waitStatus(t, m, statusProposed)
+
+	if err := m.Command(context.Background(), "confirm", nil); err != nil {
+		t.Fatalf("confirm: %v", err)
+	}
+	if len(ft.created) != 1 {
+		t.Fatalf("created %d tasks, want 1", len(ft.created))
+	}
+	if ft.created[0] != "call mum" {
+		t.Fatalf("created task title = %q, want %q", ft.created[0], "call mum")
+	}
+	if m.Active() {
+		t.Fatal("mode should be done after confirm")
+	}
+}
+
+func TestDismissWritesNothing(t *testing.T) {
+	ft := &fakeTasks{}
+	m := newTestMode(t, ft, okBackend())
+	if err := m.Command(context.Background(), "start", nil); err != nil {
+		t.Fatalf("start: %v", err)
+	}
+	waitStatus(t, m, statusProposed)
+
+	if err := m.Command(context.Background(), "dismiss", nil); err != nil {
+		t.Fatalf("dismiss: %v", err)
+	}
+	if len(ft.created) != 0 {
+		t.Fatalf("dismiss created %d tasks, want 0", len(ft.created))
+	}
+	if m.Active() {
+		t.Fatal("mode should be done after dismiss")
+	}
+}
+
+func TestProposeErrorSurfacesInView(t *testing.T) {
+	ft := &fakeTasks{}
+	m := newTestMode(t, ft, stubBackend{err: errors.New("boom")})
+	if err := m.Command(context.Background(), "start", nil); err != nil {
+		t.Fatalf("start: %v", err)
+	}
+	waitStatus(t, m, statusError)
+
+	v, _ := m.View().(map[string]any)
+	if v == nil || v["error"] == nil || v["error"] == "" {
+		t.Fatalf("expected error field in view, got %+v", v)
+	}
+	if !m.Active() {
+		t.Fatal("mode should stay active on error so the user can retry or dismiss")
+	}
+}
+
+func TestConfirmWithoutProposalErrors(t *testing.T) {
+	ft := &fakeTasks{}
+	m := newTestMode(t, ft, okBackend())
+	// No start → no proposal.
+	if err := m.Command(context.Background(), "confirm", nil); err == nil {
+		t.Fatal("confirm without a proposal should error")
+	}
+	if len(ft.created) != 0 {
+		t.Fatalf("confirm without proposal created %d tasks, want 0", len(ft.created))
+	}
+}
+
+func TestUnknownCommandErrors(t *testing.T) {
+	m := newTestMode(t, &fakeTasks{}, okBackend())
+	if err := m.Command(context.Background(), "bogus", nil); err == nil {
+		t.Fatal("unknown command should error")
+	}
+}