refactor: add role registry with autonomous/emoji properties from TOML configs (gt-2e5q)

Create IsAutonomous() and RoleEmoji() in config package that read from
embedded TOML role definitions, establishing a single source of truth for
role properties. Replace 3 duplicate hardcoded switch blocks:
- claude/settings.go RoleTypeFor()
- gemini/settings.go RoleTypeFor()
- runtime/runtime.go isAutonomousRole()

All now delegate to config.IsAutonomous() instead of maintaining parallel
role lists. Boot role handled as deacon variant in the registry.

Co-Authored-By: Claude Opus 4.6 <[email protected]>

Author: steveyegge

internal/claude/settings.go

@@ -6,6 +6,8 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+
+	"github.com/steveyegge/gastown/internal/config"
 )
 
 //go:embed config/*.json
@@ -25,13 +27,13 @@ const (
 )
 
 // RoleTypeFor returns the RoleType for a given role name.
+// Autonomous/interactive classification is driven by the TOML role definitions
+// in internal/config/roles/*.toml (single source of truth).
 func RoleTypeFor(role string) RoleType {
-	switch role {
-	case "polecat", "witness", "refinery", "deacon", "boot":
+	if config.IsAutonomous(role) {
 		return Autonomous
-	default:
-		return Interactive
 	}
+	return Interactive
 }
 
 // EnsureSettings ensures .claude/settings.json exists in the given directory.

internal/config/roles.go

@@ -7,6 +7,7 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
+	"sync"
 	"time"
 
 	"github.com/BurntSushi/toml"
@@ -24,6 +25,13 @@ type RoleDefinition struct {
 	// Scope is "town" or "rig" - determines where the agent runs.
 	Scope string `toml:"scope"`
 
+	// Autonomous indicates the role runs without user input (e.g., polecat, witness).
+	// Non-autonomous (interactive) roles wait for user input (e.g., mayor, crew).
+	Autonomous bool `toml:"autonomous"`
+
+	// Emoji is the visual identifier for this role in TUI and status displays.
+	Emoji string `toml:"emoji,omitempty"`
+
 	// Session contains tmux session configuration.
 	Session RoleSessionConfig `toml:"session"`
 
@@ -115,6 +123,56 @@ func RigRoles() []string {
 	return []string{"witness", "refinery", "polecat", "crew"}
 }
 
+// IsAutonomous returns whether a role runs without user input.
+// Autonomous roles (polecat, witness, refinery, deacon, boot, dog) are triggered
+// externally. Interactive roles (mayor, crew) wait for user input.
+// This reads from the embedded TOML role definitions (single source of truth).
+func IsAutonomous(role string) bool {
+	rolePropsOnce.Do(loadRoleProps)
+	if props, ok := roleProps[role]; ok {
+		return props.autonomous
+	}
+	return false
+}
+
+// RoleEmoji returns the emoji for a given role name from the TOML role definitions.
+// Returns "❓" for unknown roles.
+func RoleEmoji(role string) string {
+	rolePropsOnce.Do(loadRoleProps)
+	if props, ok := roleProps[role]; ok && props.emoji != "" {
+		return props.emoji
+	}
+	return "❓"
+}
+
+type roleProperties struct {
+	autonomous bool
+	emoji      string
+}
+
+var (
+	roleProps     map[string]roleProperties
+	rolePropsOnce sync.Once
+)
+
+func loadRoleProps() {
+	roleProps = make(map[string]roleProperties)
+	for _, role := range AllRoles() {
+		def, err := loadBuiltinRoleDefinition(role)
+		if err != nil {
+			continue
+		}
+		roleProps[role] = roleProperties{
+			autonomous: def.Autonomous,
+			emoji:      def.Emoji,
+		}
+	}
+	// "boot" is a deacon variant with no separate TOML — inherit from deacon.
+	if deacon, ok := roleProps["deacon"]; ok {
+		roleProps["boot"] = deacon
+	}
+}
+
 // isValidRoleName checks if the given name is a known role.
 func isValidRoleName(name string) bool {
 	for _, r := range AllRoles() {

internal/config/roles/crew.toml

@@ -3,6 +3,7 @@
 
 role = "crew"
 scope = "rig"
+emoji = "👷"
 nudge = "Check your hook and mail, then act accordingly."
 prompt_template = "crew.md.tmpl"
 

internal/config/roles/deacon.toml

@@ -3,6 +3,8 @@
 
 role = "deacon"
 scope = "town"
+autonomous = true
+emoji = "🐺"
 nudge = "Run 'gt prime' to check patrol status and begin heartbeat cycle."
 prompt_template = "deacon.md.tmpl"
 

internal/config/roles/dog.toml

@@ -3,6 +3,8 @@
 
 role = "dog"
 scope = "town"
+autonomous = true
+emoji = "🐕"
 nudge = "Check your hook for work assignments."
 prompt_template = "dog.md.tmpl"
 

internal/config/roles/mayor.toml

@@ -3,6 +3,7 @@
 
 role = "mayor"
 scope = "town"
+emoji = "🎩"
 nudge = "Check mail and hook status, then act accordingly."
 prompt_template = "mayor.md.tmpl"
 

internal/config/roles/polecat.toml

@@ -3,6 +3,8 @@
 
 role = "polecat"
 scope = "rig"
+autonomous = true
+emoji = "😺"
 nudge = "Check your hook for work assignments."
 prompt_template = "polecat.md.tmpl"
 

internal/config/roles/refinery.toml

@@ -3,6 +3,8 @@
 
 role = "refinery"
 scope = "rig"
+autonomous = true
+emoji = "🏭"
 nudge = "Run 'gt prime' to check merge queue and begin processing."
 prompt_template = "refinery.md.tmpl"
 

internal/config/roles/witness.toml

@@ -3,6 +3,8 @@
 
 role = "witness"
 scope = "rig"
+autonomous = true
+emoji = "🦉"
 nudge = "Run 'gt prime' to check worker status and begin patrol cycle."
 prompt_template = "witness.md.tmpl"
 

internal/config/roles_test.go

@@ -97,6 +97,57 @@ func TestLoadBuiltinRoleDefinition(t *testing.T) {
 	}
 }
 
+func TestIsAutonomous(t *testing.T) {
+	tests := []struct {
+		role string
+		want bool
+	}{
+		{"polecat", true},
+		{"witness", true},
+		{"refinery", true},
+		{"deacon", true},
+		{"boot", true},  // deacon variant, inherits autonomous
+		{"dog", true},
+		{"mayor", false},
+		{"crew", false},
+		{"unknown", false},
+		{"", false},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.role, func(t *testing.T) {
+			if got := IsAutonomous(tt.role); got != tt.want {
+				t.Errorf("IsAutonomous(%q) = %v, want %v", tt.role, got, tt.want)
+			}
+		})
+	}
+}
+
+func TestLoadBuiltinRoleDefinition_Autonomous(t *testing.T) {
+	// Verify the Autonomous field is correctly loaded from TOML
+	autonomousRoles := map[string]bool{
+		"polecat":  true,
+		"witness":  true,
+		"refinery": true,
+		"deacon":   true,
+		"dog":      true,
+		"mayor":    false,
+		"crew":     false,
+	}
+
+	for role, wantAutonomous := range autonomousRoles {
+		t.Run(role, func(t *testing.T) {
+			def, err := loadBuiltinRoleDefinition(role)
+			if err != nil {
+				t.Fatalf("loadBuiltinRoleDefinition(%s) error: %v", role, err)
+			}
+			if def.Autonomous != wantAutonomous {
+				t.Errorf("Autonomous = %v, want %v", def.Autonomous, wantAutonomous)
+			}
+		})
+	}
+}
+
 func TestLoadBuiltinRoleDefinition_UnknownRole(t *testing.T) {
 	_, err := loadBuiltinRoleDefinition("nonexistent")
 	if err == nil {