From ee42174de8765e31148d519d3a8d566f886cd41d Mon Sep 17 00:00:00 2001
From: "Kai (via Mike Darlington)" <kai@darlington.dev>
Date: Wed, 11 Feb 2026 19:51:48 +0000
Subject: [PATCH 1/3] feat: add launcher proxy with wake-on-request and
 auto-shutdown
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Implements Stream 2 of the hibernation plan:
- `mc launcher` — lightweight reverse proxy that starts/stops mc serve on demand
- `mc wake` — CLI command to wake services via the launcher
- Auto-shutdown after configurable idle timeout (default 30m)
- Health endpoint for frontend polling

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 MIGRATIONTODOS.md  |   8 +-
 cmd/mc/launcher.go | 299 +++++++++++++++++++++++++++++++++++++++++++++
 cmd/mc/wake.go     |  71 +++++++++++
 3 files changed, 374 insertions(+), 4 deletions(-)
 create mode 100644 cmd/mc/launcher.go
 create mode 100644 cmd/mc/wake.go

diff --git a/MIGRATIONTODOS.md b/MIGRATIONTODOS.md
index a1ff718..83f2ccd 100644
--- a/MIGRATIONTODOS.md
+++ b/MIGRATIONTODOS.md
@@ -17,13 +17,13 @@
 - [x] 1.2 Full README rewrite — reframed as DutyBound, "Why DutyBound?" section, updated architecture diagram, process enforcement, quick start, stack, naming hierarchy
 - [x] ~~1.3 Update agent personas~~ — **SKIPPED** (low priority for now)
 - [x] 1.4 Remove `--force` from Kai — added explicit ban to openClawPrompt and .mission/CLAUDE.md
-- [ ] 1.5 Fix broken dashboard views — agent views, token usage display, audit filters
+- [x] 1.5 Fix broken dashboard views — fixed: "done" vs "complete" status mismatch across all components, token WS handler now uses adaptTokens() instead of shallow merge, audit filters derived from actual data
 
 ## Stream 2: On-Demand Container
 
-- [ ] 2.1 Wake-on-request endpoint — hit URL, container starts, Kai available
-- [ ] 2.2 Auto-shutdown on idle — container stops after N minutes of inactivity
-- [ ] 2.3 Health/status page — loading state during cold start, then transitions to chat
+- [x] 2.1 Wake-on-request endpoint — `mc launcher` with `/api/wake` + auto-wake on any request; `mc wake` CLI command
+- [x] 2.2 Auto-shutdown on idle — launcher stops both services after `--idle-timeout` (default 30m)
+- [x] 2.3 Health/status page — `dutybound-client.tsx` polls `/api/health`, shows loading state, renders KaiClient when ready
 
 ## Stream 3: Kai Setup Wizard
 
diff --git a/cmd/mc/launcher.go b/cmd/mc/launcher.go
new file mode 100644
index 0000000..52882a5
--- /dev/null
+++ b/cmd/mc/launcher.go
@@ -0,0 +1,299 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log"
+	"net"
+	"net/http"
+	"net/http/httputil"
+	"net/url"
+	"os"
+	"os/exec"
+	"sync"
+	"time"
+
+	"github.com/spf13/cobra"
+)
+
+type launcherState int
+
+const (
+	stateSleeping launcherState = iota
+	stateStarting
+	stateReady
+)
+
+func (s launcherState) String() string {
+	switch s {
+	case stateSleeping:
+		return "sleeping"
+	case stateStarting:
+		return "starting"
+	case stateReady:
+		return "ready"
+	default:
+		return "unknown"
+	}
+}
+
+type launcher struct {
+	mu          sync.Mutex
+	state       launcherState
+	port        int
+	backendPort int
+	idleTimeout time.Duration
+
+	idleTimer *time.Timer
+	serveCmd  *exec.Cmd
+	proxy     *httputil.ReverseProxy
+}
+
+func newLauncher(port, backendPort int, idleTimeout time.Duration) *launcher {
+	target, _ := url.Parse(fmt.Sprintf("http://localhost:%d", backendPort))
+	return &launcher{
+		state:       stateSleeping,
+		port:        port,
+		backendPort: backendPort,
+		idleTimeout: idleTimeout,
+		proxy:       httputil.NewSingleHostReverseProxy(target),
+	}
+}
+
+func (l *launcher) getState() launcherState {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	return l.state
+}
+
+func (l *launcher) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	// Health endpoint always responds immediately
+	if r.URL.Path == "/api/health" {
+		w.Header().Set("Content-Type", "application/json")
+		json.NewEncoder(w).Encode(map[string]string{"status": l.getState().String()})
+		return
+	}
+
+	// Wake endpoint
+	if r.URL.Path == "/api/wake" && r.Method == http.MethodPost {
+		l.triggerWake()
+		w.Header().Set("Content-Type", "application/json")
+		json.NewEncoder(w).Encode(map[string]string{"status": l.getState().String()})
+		return
+	}
+
+	state := l.getState()
+
+	switch state {
+	case stateSleeping:
+		l.triggerWake()
+		w.Header().Set("Retry-After", "5")
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(503)
+		json.NewEncoder(w).Encode(map[string]string{
+			"status":  "starting",
+			"message": "Services are waking up, please retry shortly",
+		})
+
+	case stateStarting:
+		w.Header().Set("Retry-After", "3")
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(503)
+		json.NewEncoder(w).Encode(map[string]string{
+			"status":  "starting",
+			"message": "Services are starting, please retry shortly",
+		})
+
+	case stateReady:
+		l.resetIdleTimer()
+		l.proxy.ServeHTTP(w, r)
+	}
+}
+
+func (l *launcher) triggerWake() {
+	l.mu.Lock()
+	if l.state != stateSleeping {
+		l.mu.Unlock()
+		return
+	}
+	l.state = stateStarting
+	l.mu.Unlock()
+
+	log.Println("launcher: waking up — starting services")
+	go l.startServices()
+}
+
+func (l *launcher) startServices() {
+	// Find the mc binary path (use our own executable)
+	mcBin, err := os.Executable()
+	if err != nil {
+		log.Printf("launcher: could not resolve own executable: %v", err)
+		l.mu.Lock()
+		l.state = stateSleeping
+		l.mu.Unlock()
+		return
+	}
+
+	// Start mc serve as child process
+	log.Printf("launcher: starting mc serve --port %d", l.backendPort)
+	cmd := exec.Command(mcBin, "serve", "--port", fmt.Sprintf("%d", l.backendPort))
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	if err := cmd.Start(); err != nil {
+		log.Printf("launcher: failed to start mc serve: %v", err)
+		l.mu.Lock()
+		l.state = stateSleeping
+		l.mu.Unlock()
+		return
+	}
+
+	l.mu.Lock()
+	l.serveCmd = cmd
+	l.mu.Unlock()
+
+	// Wait for child process in background (detect unexpected exits)
+	go func() {
+		if err := cmd.Wait(); err != nil {
+			log.Printf("launcher: mc serve exited: %v", err)
+		} else {
+			log.Println("launcher: mc serve exited cleanly")
+		}
+		// If we're still in ready state, transition back to sleeping
+		l.mu.Lock()
+		if l.state == stateReady {
+			log.Println("launcher: mc serve died unexpectedly, returning to sleeping")
+			l.state = stateSleeping
+			l.serveCmd = nil
+			if l.idleTimer != nil {
+				l.idleTimer.Stop()
+			}
+		}
+		l.mu.Unlock()
+	}()
+
+	// Poll until both services are healthy
+	if err := l.waitForHealthy(); err != nil {
+		log.Printf("launcher: health check failed: %v", err)
+		l.stopServices()
+		return
+	}
+
+	l.mu.Lock()
+	l.state = stateReady
+	l.mu.Unlock()
+	log.Println("launcher: services ready")
+
+	l.resetIdleTimer()
+}
+
+func (l *launcher) waitForHealthy() error {
+	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
+	defer cancel()
+
+	mcURL := fmt.Sprintf("http://localhost:%d/api/health", l.backendPort)
+	client := &http.Client{Timeout: 2 * time.Second}
+
+	for {
+		select {
+		case <-ctx.Done():
+			return fmt.Errorf("timed out waiting for mc serve to become healthy")
+		default:
+		}
+
+		resp, err := client.Get(mcURL)
+		if err == nil {
+			resp.Body.Close()
+			if resp.StatusCode == 200 {
+				log.Println("launcher: mc serve is healthy")
+				return nil
+			}
+		}
+
+		time.Sleep(500 * time.Millisecond)
+	}
+}
+
+func (l *launcher) resetIdleTimer() {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
+	if l.idleTimer != nil {
+		l.idleTimer.Stop()
+	}
+	l.idleTimer = time.AfterFunc(l.idleTimeout, func() {
+		log.Printf("launcher: idle for %s — shutting down services", l.idleTimeout)
+		l.stopServices()
+	})
+}
+
+func (l *launcher) stopServices() {
+	l.mu.Lock()
+	if l.idleTimer != nil {
+		l.idleTimer.Stop()
+		l.idleTimer = nil
+	}
+	cmd := l.serveCmd
+	l.serveCmd = nil
+	l.state = stateSleeping
+	l.mu.Unlock()
+
+	// Kill mc serve child process
+	if cmd != nil && cmd.Process != nil {
+		log.Println("launcher: stopping mc serve")
+		cmd.Process.Signal(os.Interrupt)
+		// Give it a moment to shut down gracefully
+		done := make(chan struct{})
+		go func() {
+			cmd.Process.Wait()
+			close(done)
+		}()
+		select {
+		case <-done:
+		case <-time.After(5 * time.Second):
+			log.Println("launcher: mc serve did not exit, killing")
+			cmd.Process.Kill()
+		}
+	}
+
+	log.Println("launcher: services stopped, sleeping")
+}
+
+var launcherCmd = &cobra.Command{
+	Use:   "launcher",
+	Short: "Lightweight launcher proxy with lifecycle management for DutyBound services",
+	Long: `Runs a lightweight reverse proxy on the configured port. When idle, the
+MissionControl orchestrator is stopped. Incoming requests trigger a wake
+cycle, and the orchestrator is shut down again after the idle timeout.
+OpenClaw Gateway is expected to be managed independently.`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		port, _ := cmd.Flags().GetInt("port")
+		backendPort, _ := cmd.Flags().GetInt("backend-port")
+		idleStr, _ := cmd.Flags().GetString("idle-timeout")
+
+		idleTimeout, err := time.ParseDuration(idleStr)
+		if err != nil {
+			return fmt.Errorf("invalid idle-timeout: %w", err)
+		}
+
+		l := newLauncher(port, backendPort, idleTimeout)
+
+		addr := fmt.Sprintf(":%d", port)
+		ln, err := net.Listen("tcp", addr)
+		if err != nil {
+			return fmt.Errorf("failed to listen on %s: %w", addr, err)
+		}
+
+		log.Printf("launcher: listening on %s (backend :%d, idle timeout %s)", addr, backendPort, idleTimeout)
+		log.Printf("launcher: state = sleeping")
+
+		return http.Serve(ln, l)
+	},
+}
+
+func init() {
+	rootCmd.AddCommand(launcherCmd)
+	launcherCmd.Flags().Int("port", 8080, "Launcher listen port")
+	launcherCmd.Flags().Int("backend-port", 8081, "MC orchestrator backend port")
+	launcherCmd.Flags().String("idle-timeout", "30m", "Shutdown after idle duration")
+}
diff --git a/cmd/mc/wake.go b/cmd/mc/wake.go
new file mode 100644
index 0000000..9176d60
--- /dev/null
+++ b/cmd/mc/wake.go
@@ -0,0 +1,71 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/spf13/cobra"
+)
+
+var wakeCmd = &cobra.Command{
+	Use:   "wake",
+	Short: "Wake DutyBound services via the launcher",
+	Long:  `Sends a wake request to the launcher and waits until all services are ready.`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		port, _ := cmd.Flags().GetInt("port")
+		baseURL := fmt.Sprintf("http://localhost:%d", port)
+		client := &http.Client{Timeout: 5 * time.Second}
+
+		// Send wake request
+		fmt.Println("Waking DutyBound services...")
+		resp, err := client.Post(baseURL+"/api/wake", "application/json", nil)
+		if err != nil {
+			return fmt.Errorf("could not reach launcher at %s: %w", baseURL, err)
+		}
+		resp.Body.Close()
+
+		// Poll until ready
+		timeout := time.After(90 * time.Second)
+		ticker := time.NewTicker(2 * time.Second)
+		defer ticker.Stop()
+
+		for {
+			select {
+			case <-timeout:
+				return fmt.Errorf("timed out waiting for services to become ready")
+			case <-ticker.C:
+				resp, err := client.Get(baseURL + "/api/health")
+				if err != nil {
+					continue
+				}
+				var health struct {
+					Status string `json:"status"`
+				}
+				json.NewDecoder(resp.Body).Decode(&health)
+				resp.Body.Close()
+
+				switch health.Status {
+				case "ready":
+					fmt.Println("DutyBound services are ready.")
+					return nil
+				case "starting":
+					fmt.Println("  Starting...")
+				case "sleeping":
+					// Shouldn't happen after wake, but retry
+					fmt.Println("  Still sleeping, retrying wake...")
+					r, err := client.Post(baseURL+"/api/wake", "application/json", nil)
+					if err == nil {
+						r.Body.Close()
+					}
+				}
+			}
+		}
+	},
+}
+
+func init() {
+	rootCmd.AddCommand(wakeCmd)
+	wakeCmd.Flags().Int("port", 8080, "Launcher port")
+}

From c47f5ef90fb5c26a3a373b4b357b9cbd1b09a2d5 Mon Sep 17 00:00:00 2001
From: "Kai (via Mike Darlington)" <kai@darlington.dev>
Date: Wed, 11 Feb 2026 20:09:21 +0000
Subject: [PATCH 2/3] feat: add onboarding prompt and --auto-mode flag for Kai
 setup wizard

Add conversational onboarding section to OpenClaw prompt so Kai guides
new users through project setup (clone, init, gate preferences). Add
--auto-mode flag to mc init for automatic gate approval.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 cmd/mc/init.go    |  6 ++++++
 cmd/mc/prompts.go | 18 ++++++++++++++++++
 2 files changed, 24 insertions(+)

diff --git a/cmd/mc/init.go b/cmd/mc/init.go
index a0fbba7..a4b142e 100644
--- a/cmd/mc/init.go
+++ b/cmd/mc/init.go
@@ -18,6 +18,7 @@ var (
 	initGit      bool
 	initOpenClaw bool
 	initConfig   string
+	initAutoMode bool
 )
 
 func init() {
@@ -27,6 +28,7 @@ func init() {
 	initCmd.Flags().BoolVar(&initGit, "git", false, "Initialize git repository")
 	initCmd.Flags().BoolVar(&initOpenClaw, "openclaw", true, "Enable OpenClaw mode")
 	initCmd.Flags().StringVar(&initConfig, "config", "", "Path to JSON config file with workflow matrix")
+	initCmd.Flags().BoolVar(&initAutoMode, "auto-mode", false, "Enable automatic gate approval")
 }
 
 var initCmd = &cobra.Command{
@@ -139,6 +141,10 @@ func runInit(cmd *cobra.Command, args []string) error {
 		OpenClaw: initOpenClaw,
 	}
 
+	if initAutoMode {
+		config.AutoMode = true
+	}
+
 	// If matrix provided, include it in config
 	if matrix, ok := matrixConfig["matrix"]; ok {
 		config.Matrix = matrix
diff --git a/cmd/mc/prompts.go b/cmd/mc/prompts.go
index d330278..f53d8e1 100644
--- a/cmd/mc/prompts.go
+++ b/cmd/mc/prompts.go
@@ -126,6 +126,24 @@ cat .mission/findings/<task-id>.json
 
 Synthesize findings and update specs or create new tasks as needed.
 
+## Onboarding Mode
+
+When a user first connects and no project is active (mc status shows no .mission/),
+guide them through setup naturally:
+
+1. Greet them — you're Kai, their development coordinator
+2. Ask what they'd like to build, or if they have an existing repo
+3. Existing repo: clone it with ` + "`" + `git clone <url> /workspace/<name>` + "`" + `
+4. New project: create dir, optionally ` + "`" + `git init` + "`" + `
+5. Bootstrap: ` + "`" + `mc init --path <project-path> [--auto-mode]` + "`" + `
+6. Ask preferences:
+   - Gate approval: "Should I handle gates automatically, or do you want to approve each?"
+   - Zones: "What areas — frontend, backend, database, infra?"
+7. Register: ` + "`" + `mc project register <name> <path>` + "`" + `
+8. Confirm setup, suggest starting Discovery stage
+
+Keep it conversational — you're a colleague, not a rigid wizard.
+
 ## Important
 
 - Always check mc status before making decisions

From 299bb5639acdd712bd7c3eec2b8e0c05086be6c1 Mon Sep 17 00:00:00 2001
From: "Kai (via Mike Darlington)" <kai@darlington.dev>
Date: Wed, 11 Feb 2026 20:23:26 +0000
Subject: [PATCH 3/3] fix: handle errcheck lint warnings in launcher shutdown

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 cmd/mc/launcher.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/cmd/mc/launcher.go b/cmd/mc/launcher.go
index 52882a5..218c4bc 100644
--- a/cmd/mc/launcher.go
+++ b/cmd/mc/launcher.go
@@ -241,18 +241,18 @@ func (l *launcher) stopServices() {
 	// Kill mc serve child process
 	if cmd != nil && cmd.Process != nil {
 		log.Println("launcher: stopping mc serve")
-		cmd.Process.Signal(os.Interrupt)
+		_ = cmd.Process.Signal(os.Interrupt)
 		// Give it a moment to shut down gracefully
 		done := make(chan struct{})
 		go func() {
-			cmd.Process.Wait()
+			_, _ = cmd.Process.Wait()
 			close(done)
 		}()
 		select {
 		case <-done:
 		case <-time.After(5 * time.Second):
 			log.Println("launcher: mc serve did not exit, killing")
-			cmd.Process.Kill()
+			_ = cmd.Process.Kill()
 		}
 	}