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/ai/backend.go

@@ -75,7 +75,7 @@ func (b codexBackend) args(outfile string) []string {
 }
 
 func (b codexBackend) Run(ctx context.Context, prompt string) (string, error) {
-	f, err := os.CreateTemp("", "antidrift-codex-*.out")
+	f, err := os.CreateTemp("", "keel-codex-*.out")
 	if err != nil {
 		return "", fmt.Errorf("codex: temp file: %w", err)
 	}

internal/ai/proposer.go

@@ -0,0 +1,72 @@
+package ai
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"strings"
+)
+
+// OffscreenProposal is the brain's suggestion for one worthwhile thing to do
+// away from the screen. It is deliberately distinct from Proposal (the focus
+// coach's commitment shape) to avoid a name collision.
+type OffscreenProposal struct {
+	NextAction string `json:"next_action"`
+	Rationale  string `json:"rationale"`
+}
+
+// Proposer turns an off-screen brief (goals, life-domain notes, today's tasks)
+// into a single grounded off-screen action.
+type Proposer interface {
+	Propose(ctx context.Context, brief string) (OffscreenProposal, error)
+}
+
+// Propose makes Service satisfy Proposer over the same backend as Coach.
+func (s *Service) Propose(ctx context.Context, brief string) (OffscreenProposal, error) {
+	out, err := s.backend.Run(ctx, buildProposePrompt(brief))
+	if err != nil {
+		return OffscreenProposal{}, err
+	}
+	return parseOffscreenProposal(out)
+}
+
+func buildProposePrompt(brief string) string {
+	return `You are an off-screen advisor. Read the brief below — the user's goals, life-domain notes, and today's tasks — and pick ONE worthwhile thing for them to do now, away from the screen.
+
+Respond with ONLY a JSON object, no prose and no code fences, exactly this shape:
+{"next_action": "<one worthwhile off-screen action to do now>", "rationale": "<one short sentence: which goal or value it serves>"}
+
+Rules:
+- next_action: a single concrete off-screen action, doable now.
+- rationale: one short sentence naming the goal or value it serves.
+
+## Brief
+` + brief
+}
+
+// parseOffscreenProposal extracts and validates an OffscreenProposal from raw
+// CLI output, mirroring parseProposal's error discipline.
+func parseOffscreenProposal(s string) (OffscreenProposal, error) {
+	if strings.TrimSpace(s) == "" {
+		return OffscreenProposal{}, ErrEmptyResponse
+	}
+	if strings.IndexByte(s, '{') < 0 {
+		return OffscreenProposal{}, ErrNoJSON
+	}
+	jsonStr, err := extractJSON(s)
+	if err != nil {
+		return OffscreenProposal{}, fmt.Errorf("%w: %v", ErrInvalidProposal, err)
+	}
+	var raw OffscreenProposal
+	if err := json.Unmarshal([]byte(jsonStr), &raw); err != nil {
+		return OffscreenProposal{}, fmt.Errorf("%w: %v", ErrInvalidProposal, err)
+	}
+	na := strings.TrimSpace(raw.NextAction)
+	if na == "" {
+		return OffscreenProposal{}, ErrInvalidProposal
+	}
+	return OffscreenProposal{
+		NextAction: na,
+		Rationale:  strings.TrimSpace(raw.Rationale),
+	}, nil
+}

internal/ai/proposer_test.go

@@ -0,0 +1,43 @@
+package ai
+
+import (
+	"context"
+	"errors"
+	"strings"
+	"testing"
+)
+
+func TestProposeParsesProposal(t *testing.T) {
+	svc := NewService(&fakeBackend{out: `{"next_action":"call mum","rationale":"people goal"}`})
+	p, err := svc.Propose(context.Background(), "off-screen brief")
+	if err != nil {
+		t.Fatalf("Propose: %v", err)
+	}
+	if p.NextAction != "call mum" || p.Rationale != "people goal" {
+		t.Fatalf("proposal = %+v", p)
+	}
+}
+
+func TestProposeBackendError(t *testing.T) {
+	fb := &fakeBackend{err: errors.New("boom")}
+	if _, err := NewService(fb).Propose(context.Background(), "brief"); err == nil {
+		t.Fatal("want backend error")
+	}
+}
+
+func TestProposeUnparseable(t *testing.T) {
+	fb := &fakeBackend{out: "I cannot help."}
+	if _, err := NewService(fb).Propose(context.Background(), "brief"); !errors.Is(err, ErrNoJSON) {
+		t.Fatalf("want ErrNoJSON, got %v", err)
+	}
+}
+
+func TestProposePromptIncludesBrief(t *testing.T) {
+	fb := &fakeBackend{out: `{"next_action":"a","rationale":"b"}`}
+	if _, err := NewService(fb).Propose(context.Background(), "water the tomato plants"); err != nil {
+		t.Fatalf("Propose: %v", err)
+	}
+	if !strings.Contains(fb.gotPrompt, "water the tomato plants") {
+		t.Fatalf("prompt should embed the brief, got: %s", fb.gotPrompt)
+	}
+}