feat: implement rig/town-level mail routing and shared beads for polecats

internal/mail/mailbox.go

@@ -22,6 +22,7 @@ var (
 type Mailbox struct {
 	identity string // beads identity (e.g., "gastown-Toast")
 	workDir  string // directory to run bd commands in
+	beadsDir string // explicit .beads directory path (set via BEADS_DIR)
 	path     string // for legacy JSONL mode (crew workers)
 	legacy   bool   // true = use JSONL files, false = use beads
 }
@@ -45,12 +46,22 @@ func NewMailboxBeads(identity, workDir string) *Mailbox {
 }
 
 // NewMailboxFromAddress creates a beads-backed mailbox from a GGT address.
-// The address is stored as-is (not converted to identity) to match how
-// messages are stored with their assignee field.
 func NewMailboxFromAddress(address, workDir string) *Mailbox {
+	beadsDir := filepath.Join(workDir, ".beads")
 	return &Mailbox{
-		identity: address, // Use address directly, not identity format
+		identity: addressToIdentity(address),
 		workDir:  workDir,
+		beadsDir: beadsDir,
+		legacy:   false,
+	}
+}
+
+// NewMailboxWithBeadsDir creates a mailbox with an explicit beads directory.
+func NewMailboxWithBeadsDir(address, workDir, beadsDir string) *Mailbox {
+	return &Mailbox{
+		identity: addressToIdentity(address),
+		workDir:  workDir,
+		beadsDir: beadsDir,
 		legacy:   false,
 	}
 }
@@ -74,13 +85,13 @@ func (m *Mailbox) List() ([]*Message, error) {
 }
 
 func (m *Mailbox) listBeads() ([]*Message, error) {
-	// bd list --type=message --assignee=<identity> --status=open --json
+	// bd mail inbox --json
-	cmd := exec.Command("bd", "list",
+	cmd := exec.Command("bd", "mail", "inbox", "--json")
-		"--type", "message",
-		"--assignee", m.identity,
-		"--status", "open",
-		"--json")
 	cmd.Dir = m.workDir
+	cmd.Env = append(cmd.Environ(),
+		"BD_IDENTITY="+m.identity,
+		"BEADS_DIR="+m.beadsDir,
+	)
 
 	var stdout, stderr bytes.Buffer
 	cmd.Stdout = &stdout
@@ -104,14 +115,6 @@ func (m *Mailbox) listBeads() ([]*Message, error) {
 		return nil, err
 	}
 
-	// Sort pinned messages first, then by timestamp (newest first)
-	sort.Slice(beadsMsgs, func(i, j int) bool {
-		if beadsMsgs[i].Pinned != beadsMsgs[j].Pinned {
-			return beadsMsgs[i].Pinned // pinned comes first
-		}
-		return beadsMsgs[i].CreatedAt.After(beadsMsgs[j].CreatedAt)
-	})
-
 	// Convert to GGT messages
 	var messages []*Message
 	for _, bm := range beadsMsgs {
@@ -186,9 +189,9 @@ func (m *Mailbox) Get(id string) (*Message, error) {
 }
 
 func (m *Mailbox) getBeads(id string) (*Message, error) {
-	// bd show <id> --json returns an array with one element
+	cmd := exec.Command("bd", "mail", "read", id, "--json")
-	cmd := exec.Command("bd", "show", id, "--json")
 	cmd.Dir = m.workDir
+	cmd.Env = append(cmd.Environ(), "BEADS_DIR="+m.beadsDir)
 
 	var stdout, stderr bytes.Buffer
 	cmd.Stdout = &stdout
@@ -205,16 +208,12 @@ func (m *Mailbox) getBeads(id string) (*Message, error) {
 		return nil, err
 	}
 
-	// bd show returns an array with one element
+	var bm BeadsMessage
-	var beadsMsgs []BeadsMessage
+	if err := json.Unmarshal(stdout.Bytes(), &bm); err != nil {
-	if err := json.Unmarshal(stdout.Bytes(), &beadsMsgs); err != nil {
 		return nil, err
 	}
-	if len(beadsMsgs) == 0 {
-		return nil, ErrMessageNotFound
-	}
 
-	return beadsMsgs[0].ToMessage(), nil
+	return bm.ToMessage(), nil
 }
 
 func (m *Mailbox) getLegacy(id string) (*Message, error) {
@@ -239,9 +238,9 @@ func (m *Mailbox) MarkRead(id string) error {
 }
 
 func (m *Mailbox) markReadBeads(id string) error {
-	// bd close <id> marks the message as read
+	cmd := exec.Command("bd", "mail", "ack", id)
-	cmd := exec.Command("bd", "close", id, "--reason", "Message read")
 	cmd.Dir = m.workDir
+	cmd.Env = append(cmd.Environ(), "BEADS_DIR="+m.beadsDir)
 
 	var stderr bytes.Buffer
 	cmd.Stderr = &stderr
@@ -408,12 +407,13 @@ func (m *Mailbox) ListByThread(threadID string) ([]*Message, error) {
 }
 
 func (m *Mailbox) listByThreadBeads(threadID string) ([]*Message, error) {
-	// bd list --type=message --label=thread:<thread-id> --json
+	// bd message thread <thread-id> --json
-	cmd := exec.Command("bd", "list",
+	cmd := exec.Command("bd", "message", "thread", threadID, "--json")
-		"--type", "message",
-		"--label", "thread:"+threadID,
-		"--json")
 	cmd.Dir = m.workDir
+	cmd.Env = append(cmd.Environ(),
+		"BD_IDENTITY="+m.identity,
+		"BEADS_DIR="+m.beadsDir,
+	)
 
 	var stdout, stderr bytes.Buffer
 	cmd.Stdout = &stdout

internal/mail/router.go

@@ -4,72 +4,143 @@ import (
 	"bytes"
 	"errors"
 	"fmt"
+	"os"
 	"os/exec"
+	"path/filepath"
 	"strings"
 
 	"github.com/steveyegge/gastown/internal/tmux"
 )
 
 // Router handles message delivery via beads.
+// It routes messages to the correct beads database based on address:
+// - Town-level (mayor/, deacon/) -> {townRoot}/.beads
+// - Rig-level (rig/polecat) -> {townRoot}/{rig}/.beads
 type Router struct {
-	workDir string // directory to run bd commands in
+	workDir  string // fallback directory to run bd commands in
-	tmux    *tmux.Tmux
+	townRoot string // town root directory (e.g., ~/gt)
+	tmux     *tmux.Tmux
 }
 
 // NewRouter creates a new mail router.
 // workDir should be a directory containing a .beads database.
+// The town root is auto-detected from workDir if possible.
 func NewRouter(workDir string) *Router {
+	// Try to detect town root from workDir
+	townRoot := detectTownRoot(workDir)
+
 	return &Router{
-		workDir: workDir,
+		workDir:  workDir,
-		tmux:    tmux.NewTmux(),
+		townRoot: townRoot,
+		tmux:     tmux.NewTmux(),
 	}
 }
 
-// Send delivers a message via beads issue creation.
+// NewRouterWithTownRoot creates a router with an explicit town root.
-// Messages are stored as beads issues with type=message.
+func NewRouterWithTownRoot(workDir, townRoot string) *Router {
-func (r *Router) Send(msg *Message) error {
+	return &Router{
-	// Use address directly for assignee (maintains compatibility with old messages)
+		workDir:  workDir,
-	// The from address is converted to identity format for the labels
+		townRoot: townRoot,
-	fromIdentity := addressToIdentity(msg.From)
+		tmux:     tmux.NewTmux(),
+	}
+}
 
-	// Build command: bd create --type=message --title="subject" --assignee=recipient
+// detectTownRoot finds the town root by looking for mayor/town.json.
-	// Assignee uses the original address format to match how bd mail stored them
+func detectTownRoot(startDir string) string {
-	args := []string{"create",
+	dir := startDir
-		"--type", "message",
+	for {
-		"--title", msg.Subject,
+		// Check for primary marker (mayor/town.json)
-		"--assignee", msg.To,
+		markerPath := filepath.Join(dir, "mayor", "town.json")
+		if _, err := os.Stat(markerPath); err == nil {
+			return dir
+		}
+
+		// Move up
+		parent := filepath.Dir(dir)
+		if parent == dir {
+			break
+		}
+		dir = parent
+	}
+	return ""
+}
+
+// resolveBeadsDir returns the correct .beads directory for the given address.
+// Town-level addresses (mayor/, deacon/) use {townRoot}/.beads.
+// Rig-level addresses (rig/polecat) use {townRoot}/{rig}/.beads.
+func (r *Router) resolveBeadsDir(address string) string {
+	// If no town root, fall back to workDir's .beads
+	if r.townRoot == "" {
+		return filepath.Join(r.workDir, ".beads")
 	}
 
-	// Add body if present
+	// Town-level agents: mayor/, deacon/
-	if msg.Body != "" {
+	if isTownLevelAddress(address) {
-		args = append(args, "--description", msg.Body)
+		return filepath.Join(r.townRoot, ".beads")
+	}
+
+	// Rig-level addresses: rig/polecat, rig/refinery
+	parts := strings.SplitN(address, "/", 2)
+	if len(parts) >= 1 && parts[0] != "" {
+		rig := parts[0]
+		rigBeadsDir := filepath.Join(r.townRoot, rig, ".beads")
+		// Check if rig beads exists
+		if _, err := os.Stat(rigBeadsDir); err == nil {
+			return rigBeadsDir
+		}
+	}
+
+	// Fall back to town-level beads
+	return filepath.Join(r.townRoot, ".beads")
+}
+
+// isTownLevelAddress returns true if the address is for a town-level agent.
+func isTownLevelAddress(address string) bool {
+	addr := strings.TrimSuffix(address, "/")
+	return addr == "mayor" || addr == "deacon"
+}
+
+// Send delivers a message via beads message.
+// Routes the message to the correct beads database based on recipient address.
+func (r *Router) Send(msg *Message) error {
+	// Convert addresses to beads identities
+	toIdentity := addressToIdentity(msg.To)
+	fromIdentity := addressToIdentity(msg.From)
+
+	// Build command: bd mail send <recipient> -s <subject> -m <body>
+	args := []string{"mail", "send", toIdentity,
+		"-s", msg.Subject,
+		"-m", msg.Body,
 	}
 
 	// Add priority flag
 	beadsPriority := PriorityToBeads(msg.Priority)
 	args = append(args, "--priority", fmt.Sprintf("%d", beadsPriority))
 
-	// Build labels for metadata (from, thread-id, reply-to, message-type)
+	// Add message type if set
-	var labels []string
-	labels = append(labels, "from:"+fromIdentity)
-
-	if msg.ThreadID != "" {
-		labels = append(labels, "thread:"+msg.ThreadID)
-	}
-	if msg.ReplyTo != "" {
-		labels = append(labels, "reply-to:"+msg.ReplyTo)
-	}
 	if msg.Type != "" && msg.Type != TypeNotification {
-		labels = append(labels, "msg-type:"+string(msg.Type))
+		args = append(args, "--type", string(msg.Type))
 	}
 
-	if len(labels) > 0 {
+	// Add thread ID if set
-		args = append(args, "--labels", strings.Join(labels, ","))
+	if msg.ThreadID != "" {
+		args = append(args, "--thread-id", msg.ThreadID)
 	}
 
+	// Add reply-to if set
+	if msg.ReplyTo != "" {
+		args = append(args, "--reply-to", msg.ReplyTo)
+	}
+
+	// Resolve the correct beads directory for the recipient
+	beadsDir := r.resolveBeadsDir(msg.To)
+
 	cmd := exec.Command("bd", args...)
-	cmd.Env = append(cmd.Environ(), "BEADS_AGENT_NAME="+fromIdentity)
+	cmd.Env = append(cmd.Environ(),
-	cmd.Dir = r.workDir
+		"BEADS_AGENT_NAME="+fromIdentity,
+		"BEADS_DIR="+beadsDir,
+	)
+	cmd.Dir = filepath.Dir(beadsDir) // Run in parent of .beads
 
 	var stderr bytes.Buffer
 	cmd.Stderr = &stderr
@@ -89,8 +160,11 @@ func (r *Router) Send(msg *Message) error {
 }
 
 // GetMailbox returns a Mailbox for the given address.
+// Routes to the correct beads database based on the address.
 func (r *Router) GetMailbox(address string) (*Mailbox, error) {
-	return NewMailboxFromAddress(address, r.workDir), nil
+	beadsDir := r.resolveBeadsDir(address)
+	workDir := filepath.Dir(beadsDir) // Parent of .beads
+	return NewMailboxFromAddress(address, workDir), nil
 }
 
 // notifyRecipient sends a notification to a recipient's tmux session.

internal/polecat/manager.go

@@ -139,12 +139,12 @@ func (m *Manager) Add(name string) (*Polecat, error) {
 		}
 	}
 
-	// Create beads redirect to share rig-level beads database
+	// Set up shared beads: polecat uses rig's .beads via redirect file.
-	// This eliminates git sync overhead - all polecats use same daemon
+	// This eliminates git sync overhead - all polecats share one database.
-	if err := m.createBeadsRedirect(polecatPath); err != nil {
+	if err := m.setupSharedBeads(polecatPath); err != nil {
-		// Non-fatal - polecat can still work with its own .beads/ if needed
+		// Non-fatal - polecat can still work with local beads
 		// Log warning but don't fail the spawn
-		fmt.Fprintf(os.Stderr, "Warning: could not create beads redirect: %v\n", err)
+		fmt.Printf("Warning: could not set up shared beads: %v\n", err)
 	}
 
 	// Return polecat with derived state (no issue assigned yet = idle)
@@ -522,47 +522,37 @@ func (m *Manager) loadFromBeads(name string) (*Polecat, error) {
 	}, nil
 }
 
-// createBeadsRedirect creates a .beads/redirect file in the polecat directory
+// setupSharedBeads creates a redirect file so the polecat uses the rig's shared .beads database.
-// that points to the rig-level shared beads database. This eliminates the need
+// This eliminates the need for git sync between polecat clones - all polecats share one database.
-// for git sync between polecats - they all share the same daemon and database.
 //
-// Directory structure:
+// Structure:
-//   gastown/
+//
-//     .beads/              <- Shared database (created if missing)
+//	rig/
-//     polecats/
+//	  .beads/              <- Shared database (ensured to exist)
-//       nux/
+//	  polecats/
-//         .beads/
+//	    <name>/
-//           redirect       <- Contains "../../.beads"
+//	      .beads/
-func (m *Manager) createBeadsRedirect(polecatPath string) error {
+//	        redirect       <- Contains "../../.beads"
-	// Rig-level beads path
+func (m *Manager) setupSharedBeads(polecatPath string) error {
-	rigBeadsPath := filepath.Join(m.rig.Path, ".beads")
+	// Ensure rig root has .beads/ directory
-
+	rigBeadsDir := filepath.Join(m.rig.Path, ".beads")
-	// Ensure rig-level .beads/ exists
+	if err := os.MkdirAll(rigBeadsDir, 0755); err != nil {
-	if _, err := os.Stat(rigBeadsPath); os.IsNotExist(err) {
+		return fmt.Errorf("creating rig .beads dir: %w", err)
-		// Initialize rig-level beads if it doesn't exist
-		// This creates the database and config
-		if err := os.MkdirAll(rigBeadsPath, 0755); err != nil {
-			return fmt.Errorf("creating rig beads dir: %w", err)
-		}
-		// Note: bd will auto-initialize when first used
 	}
 
-	// Create polecat .beads directory
+	// Create polecat's .beads directory
-	polecatBeadsPath := filepath.Join(polecatPath, ".beads")
+	polecatBeadsDir := filepath.Join(polecatPath, ".beads")
-	if err := os.MkdirAll(polecatBeadsPath, 0755); err != nil {
+	if err := os.MkdirAll(polecatBeadsDir, 0755); err != nil {
-		return fmt.Errorf("creating polecat beads dir: %w", err)
+		return fmt.Errorf("creating polecat .beads dir: %w", err)
 	}
 
-	// Calculate relative path from polecat to rig beads
+	// Create redirect file pointing to rig's .beads
-	// polecatPath is like: <rig>/polecats/<name>
+	// Path is relative from polecats/<name>/.beads/ to rig/.beads/
-	// rigBeadsPath is like: <rig>/.beads
+	redirectPath := filepath.Join(polecatBeadsDir, "redirect")
-	// So relative path is: ../../.beads
+	redirectContent := "../../.beads\n"
-	redirectPath := filepath.Join(polecatBeadsPath, "redirect")
-	relativePath := "../../.beads"
 
-	// Write redirect file
+	if err := os.WriteFile(redirectPath, []byte(redirectContent), 0644); err != nil {
-	if err := os.WriteFile(redirectPath, []byte(relativePath+"\n"), 0644); err != nil {
+		return fmt.Errorf("creating redirect file: %w", err)
-		return fmt.Errorf("writing redirect file: %w", err)
 	}
 
 	return nil