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/focus/mode.go

@@ -0,0 +1,82 @@
+package focus
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"time"
+
+	"keel/internal/evidence"
+	"keel/internal/mode"
+	"keel/internal/mode/focus/domain"
+)
+
+// Compile-time assertions: focus.Mode must satisfy the harness contracts.
+var _ mode.Mode = (*Mode)(nil)
+var _ mode.EvidenceConsumer = (*Mode)(nil)
+var _ mode.Expirer = (*Mode)(nil)
+
+// Kind identifies this mode to the harness.
+func (c *Mode) Kind() string { return "focus" }
+
+var errBadPayload = errors.New("focus: invalid command payload")
+
+type commitmentPayload struct {
+	NextAction           string   `json:"next_action"`
+	SuccessCondition     string   `json:"success_condition"`
+	TimeboxSecs          int64    `json:"timebox_secs"`
+	AllowedWindowClasses []string `json:"allowed_window_classes"`
+	Enforce              bool     `json:"enforce"`
+}
+
+// Command maps surface command names onto the existing focus transitions.
+func (c *Mode) Command(ctx context.Context, name string, payload json.RawMessage) error {
+	switch name {
+	case "planning":
+		return c.EnterPlanning()
+	case "coach":
+		var r struct {
+			Intent string `json:"intent"`
+		}
+		if err := json.Unmarshal(payload, &r); err != nil {
+			return errBadPayload
+		}
+		return c.RequestCoach(r.Intent)
+	case "commitment":
+		var r commitmentPayload
+		if err := json.Unmarshal(payload, &r); err != nil {
+			return errBadPayload
+		}
+		level := domain.EnforcementWarn
+		if r.Enforce {
+			level = domain.EnforcementBlock
+		}
+		return c.StartManualCommitment(r.NextAction, r.SuccessCondition,
+			time.Duration(r.TimeboxSecs)*time.Second, r.AllowedWindowClasses, level)
+	case "complete":
+		return c.Complete()
+	case "end":
+		return c.End()
+	case "refocus":
+		return c.Refocus()
+	case "ontask":
+		return c.OnTask()
+	default:
+		return fmt.Errorf("focus: unknown command %q", name)
+	}
+}
+
+// View returns the focus state projection (the existing State shape).
+func (c *Mode) View() any { return c.State() }
+
+// Active is true from Planning through Review. End() drives the runtime back to
+// Locked, which the harness reads as "done" and releases.
+func (c *Mode) Active() bool {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	return c.runtimeState != domain.RuntimeLocked
+}
+
+// OnWindow forwards the sensor stream to the existing evidence recorder.
+func (c *Mode) OnWindow(w evidence.WindowSnapshot) { c.RecordWindow(w) }