fix(docs): use pinned CLI path in rekindle.md and fellowship SKILL.md

.gitignore

@@ -2,3 +2,9 @@ docs/
 .worktrees/
 .fellowship/
 cli/fellowship
+.DS_Store
+.fastembed_cache/
+.shire/
+.superpowers/
+scripts/
+shire.toml

cli/cmd/fellowship/main.go

@@ -913,7 +913,7 @@ func runDashboard(d *db.DB, args []string) int {
 	poll := fs.Int("poll", 5, "Poll interval in seconds")
 	fs.Parse(args)
 
-	srv := dashboard.NewServer(d, *poll)
+	srv := dashboard.NewServer(d, gitRootOrCwd(), *poll)
 
 	addr := fmt.Sprintf("localhost:%d", *port)
 	url := fmt.Sprintf("http://%s", addr)

cli/go.mod

@@ -2,7 +2,10 @@ module github.com/justinjdev/fellowship/cli
 
 go 1.25.5
 
-require zombiezen.com/go/sqlite v1.4.2
+require (
+	github.com/gorilla/websocket v1.5.3
+	zombiezen.com/go/sqlite v1.4.2
+)
 
 require (
 	github.com/dustin/go-humanize v1.0.1 // indirect

cli/go.sum

@@ -4,6 +4,8 @@ github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
 github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
+github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/ncruces/go-strftime v0.1.9 h1:bY0MQC28UADQmHmaF5dgpLmImcShSi2kHU9XLdhx/f4=

cli/internal/dashboard/commands.go

@@ -0,0 +1,120 @@
+package dashboard
+
+import (
+	"encoding/json"
+	"net/http"
+	"time"
+)
+
+type SpawnQuestRequest struct {
+	Task    string `json:"task"`
+	Branch  string `json:"branch,omitempty"`
+	Company string `json:"company,omitempty"`
+}
+
+type SpawnScoutRequest struct {
+	Question string `json:"question"`
+}
+
+type QuestIDRequest struct {
+	QuestID string `json:"quest_id"`
+}
+
+type QueuedResponse struct {
+	Queued    bool   `json:"queued"`
+	CommandID string `json:"command_id"`
+}
+
+func (s *Server) handleSpawnQuest(w http.ResponseWriter, r *http.Request) {
+	var req SpawnQuestRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "invalid request body", http.StatusBadRequest)
+		return
+	}
+	if req.Task == "" {
+		http.Error(w, "task is required", http.StatusBadRequest)
+		return
+	}
+	params, _ := json.Marshal(req)
+	cmd, err := EnqueueCommand(s.gitRoot, ActionSpawnQuest, params)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	s.hub.Broadcast(WSEvent{Type: "command-queued", CommandID: cmd.ID, Timestamp: time.Now().Unix()})
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(QueuedResponse{Queued: true, CommandID: cmd.ID})
+}
+
+func (s *Server) handleSpawnScout(w http.ResponseWriter, r *http.Request) {
+	var req SpawnScoutRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "invalid request body", http.StatusBadRequest)
+		return
+	}
+	if req.Question == "" {
+		http.Error(w, "question is required", http.StatusBadRequest)
+		return
+	}
+	params, _ := json.Marshal(req)
+	cmd, err := EnqueueCommand(s.gitRoot, ActionSpawnScout, params)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	s.hub.Broadcast(WSEvent{Type: "command-queued", CommandID: cmd.ID, Timestamp: time.Now().Unix()})
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(QueuedResponse{Queued: true, CommandID: cmd.ID})
+}
+
+func (s *Server) handleKillQuest(w http.ResponseWriter, r *http.Request) {
+	var req QuestIDRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "invalid request body", http.StatusBadRequest)
+		return
+	}
+	if req.QuestID == "" {
+		http.Error(w, "quest_id is required", http.StatusBadRequest)
+		return
+	}
+	params, _ := json.Marshal(req)
+	cmd, err := EnqueueCommand(s.gitRoot, ActionKillQuest, params)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	s.hub.Broadcast(WSEvent{Type: "command-queued", CommandID: cmd.ID, Timestamp: time.Now().Unix()})
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(QueuedResponse{Queued: true, CommandID: cmd.ID})
+}
+
+func (s *Server) handleRestartQuest(w http.ResponseWriter, r *http.Request) {
+	var req QuestIDRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "invalid request body", http.StatusBadRequest)
+		return
+	}
+	if req.QuestID == "" {
+		http.Error(w, "quest_id is required", http.StatusBadRequest)
+		return
+	}
+	params, _ := json.Marshal(req)
+	cmd, err := EnqueueCommand(s.gitRoot, ActionRestartQuest, params)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	s.hub.Broadcast(WSEvent{Type: "command-queued", CommandID: cmd.ID, Timestamp: time.Now().Unix()})
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(QueuedResponse{Queued: true, CommandID: cmd.ID})
+}
+
+func (s *Server) handleCommands(w http.ResponseWriter, r *http.Request) {
+	q, err := LoadCommandQueue(s.gitRoot)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(q.Commands)
+}

cli/internal/dashboard/data.go

@@ -0,0 +1,168 @@
+package dashboard
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/justinjdev/fellowship/cli/internal/autopsy"
+	"github.com/justinjdev/fellowship/cli/internal/db"
+	"github.com/justinjdev/fellowship/cli/internal/tome"
+)
+
+// GET /api/autopsies — list all autopsy records
+// GET /api/autopsies/<filename> — single autopsy detail
+func (s *Server) handleAutopsies(w http.ResponseWriter, r *http.Request) {
+	suffix := strings.TrimPrefix(r.URL.Path, "/api/autopsies")
+	suffix = strings.TrimPrefix(suffix, "/")
+
+	// Individual autopsy lookup not supported via SQLite API; scan all and filter.
+	var records []autopsy.Autopsy
+	err := s.db.WithConn(context.Background(), func(conn *db.Conn) error {
+		var loadErr error
+		records, loadErr = autopsy.Scan(conn, autopsy.ScanOptions{}, autopsy.DefaultExpiryDays)
+		return loadErr
+	})
+
+	if suffix != "" {
+		// Filter to matching record by quest name
+		for _, r := range records {
+			if r.Quest == suffix {
+				w.Header().Set("Content-Type", "application/json")
+				json.NewEncoder(w).Encode(r)
+				return
+			}
+		}
+		http.Error(w, "autopsy not found", http.StatusNotFound)
+		return
+	}
+	if err != nil {
+		w.Header().Set("Content-Type", "application/json")
+		json.NewEncoder(w).Encode([]interface{}{})
+		return
+	}
+	if records == nil {
+		records = []autopsy.Autopsy{}
+	}
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(records)
+}
+
+// GET /api/tome/<questName> — quest tome (CV)
+func (s *Server) handleTome(w http.ResponseWriter, r *http.Request) {
+	questName := strings.TrimPrefix(r.URL.Path, "/api/tome/")
+	if questName == "" {
+		http.Error(w, "quest name required", http.StatusBadRequest)
+		return
+	}
+
+	var t *tome.QuestTome
+	err := s.db.WithConn(context.Background(), func(conn *db.Conn) error {
+		var loadErr error
+		t, loadErr = tome.Load(conn, questName)
+		return loadErr
+	})
+	if err != nil || t == nil {
+		w.Header().Set("Content-Type", "application/json")
+		json.NewEncoder(w).Encode(map[string]interface{}{
+			"quest_name":       questName,
+			"phases_completed": []interface{}{},
+			"gate_history":     []interface{}{},
+			"files_touched":    []string{},
+		})
+		return
+	}
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(t)
+}
+
+// GET /api/config — read fellowship config
+func (s *Server) handleConfigRead(w http.ResponseWriter, r *http.Request) {
+	result := map[string]interface{}{
+		"global":  nil,
+		"project": nil,
+	}
+
+	if home, err := os.UserHomeDir(); err == nil {
+		globalPath := filepath.Join(home, ".claude", "fellowship.json")
+		if data, err := os.ReadFile(globalPath); err == nil {
+			var global interface{}
+			if json.Unmarshal(data, &global) == nil {
+				result["global"] = global
+			}
+		}
+	} // silently skip global config if home directory unavailable
+
+	projectPath := filepath.Join(s.gitRoot, ".fellowship", "config.json")
+	if data, err := os.ReadFile(projectPath); err == nil {
+		var project interface{}
+		if json.Unmarshal(data, &project) == nil {
+			result["project"] = project
+		}
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(result)
+}
+
+type ConfigWriteRequest struct {
+	Key   string      `json:"key"`
+	Value interface{} `json:"value"`
+	Scope string      `json:"scope"`
+}
+
+func (s *Server) handleConfigWrite(w http.ResponseWriter, r *http.Request) {
+	var req ConfigWriteRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "invalid request body", http.StatusBadRequest)
+		return
+	}
+
+	var configPath string
+	switch req.Scope {
+	case "global":
+		home, _ := os.UserHomeDir()
+		configPath = filepath.Join(home, ".claude", "fellowship.json")
+	case "project":
+		configPath = filepath.Join(s.gitRoot, ".fellowship", "config.json")
+	default:
+		http.Error(w, "scope must be 'global' or 'project'", http.StatusBadRequest)
+		return
+	}
+
+	existing := make(map[string]interface{})
+	if data, err := os.ReadFile(configPath); err == nil {
+		if err := json.Unmarshal(data, &existing); err != nil {
+			http.Error(w, "existing config file contains invalid JSON", http.StatusInternalServerError)
+			return
+		}
+	}
+
+	existing[req.Key] = req.Value
+
+	if err := os.MkdirAll(filepath.Dir(configPath), 0755); err != nil {
+		http.Error(w, "failed to create config directory", http.StatusInternalServerError)
+		return
+	}
+	data, err := json.MarshalIndent(existing, "", "  ")
+	if err != nil {
+		http.Error(w, "failed to marshal config", http.StatusInternalServerError)
+		return
+	}
+	tmp := configPath + ".tmp"
+	if err := os.WriteFile(tmp, data, 0644); err != nil {
+		http.Error(w, "failed to write config", http.StatusInternalServerError)
+		return
+	}
+	if err := os.Rename(tmp, configPath); err != nil {
+		os.Remove(tmp) // best-effort cleanup
+		http.Error(w, "failed to save config", http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(map[string]bool{"ok": true})
+}

cli/internal/dashboard/embed.go

@@ -2,5 +2,5 @@ package dashboard
 
 import "embed"
 
-//go:embed static
+//go:embed all:static
 var staticFiles embed.FS