fix: add agentBeadID determinism test and capacity check comment (gt-27k)

Address PR gastownhall#3677 review feedback:
1. Add TestAgentBeadID_Deterministic regression test that constructs
   Managers from the same rig path (including after cwd change) and
   asserts agentBeadID returns identical strings — locks in the gt-lph
   fix against future refactors of NewManager.
2. Add comment at CheckDoltServerCapacity documenting the intentional
   behavior change: the old skip-on-error path (return nil when
   workspace.Find failed) was silently removed, and errors now
   propagate as fail-closed — the right behavior for gt-lfc0d.

Author: 8888

internal/polecat/manager.go

@@ -290,6 +290,12 @@ func (m *Manager) CheckDoltHealth() error {
 // Fails closed if the check errors — a server that can't report capacity is likely
 // already under stress (gt-lfc0d).
 func (m *Manager) CheckDoltServerCapacity() error {
+	// NOTE: Prior to gt-lph, this method called workspace.Find to locate townRoot,
+	// which could fail and silently skip the capacity check (return nil). Now that
+	// m.townRoot is computed deterministically at Manager construction, errors from
+	// HasConnectionCapacity always propagate — this is intentional. A server that
+	// can't report capacity is likely under stress, and silently passing was a
+	// latent bug that allowed connection storms under load (gt-lfc0d).
 	hasCapacity, active, err := doltserver.HasConnectionCapacity(m.townRoot)
 	if err != nil {
 		// Fail closed: if we can't check capacity, the server may be overloaded.

internal/polecat/manager_test.go

@@ -215,6 +215,66 @@ func TestAssigneeID(t *testing.T) {
 	}
 }
 
+// TestAgentBeadID_Deterministic verifies that agentBeadID returns the same string
+// on repeated calls regardless of process working directory. Regression test for
+// gt-lph: the old implementation called workspace.Find on each invocation, which
+// could resolve differently depending on cwd, causing non-deterministic IDs across
+// Manager instances for the same rig path.
+func TestAgentBeadID_Deterministic(t *testing.T) {
+	townRoot := t.TempDir()
+	rigPath := filepath.Join(townRoot, "myrig")
+	if err := os.MkdirAll(rigPath, 0755); err != nil {
+		t.Fatalf("mkdir rig: %v", err)
+	}
+
+	r := &rig.Rig{
+		Name: "myrig",
+		Path: rigPath,
+	}
+
+	// Construct two Managers from the same rig path — they must produce
+	// identical agentBeadIDs regardless of construction context.
+	m1 := NewManager(r, git.NewGit(rigPath), nil)
+	m2 := NewManager(r, git.NewGit(rigPath), nil)
+
+	id1a := m1.agentBeadID("Toast")
+	id1b := m1.agentBeadID("Toast")
+	id2 := m2.agentBeadID("Toast")
+
+	// Same Manager, repeated calls — must be identical.
+	if id1a != id1b {
+		t.Errorf("agentBeadID not stable across calls: %q vs %q", id1a, id1b)
+	}
+
+	// Different Manager, same rig — must be identical.
+	if id1a != id2 {
+		t.Errorf("agentBeadID differs across Managers for same rig: %q vs %q", id1a, id2)
+	}
+
+	// Verify the ID is non-empty and contains expected components.
+	if id1a == "" {
+		t.Fatal("agentBeadID returned empty string")
+	}
+
+	// Change process working directory and construct a third Manager —
+	// the ID must still match (the old bug: workspace.Find resolved
+	// differently from different cwds).
+	origDir, err := os.Getwd()
+	if err != nil {
+		t.Fatalf("Getwd: %v", err)
+	}
+	if err := os.Chdir(townRoot); err != nil {
+		t.Fatalf("Chdir to townRoot: %v", err)
+	}
+	defer func() { _ = os.Chdir(origDir) }()
+
+	m3 := NewManager(r, git.NewGit(rigPath), nil)
+	id3 := m3.agentBeadID("Toast")
+	if id1a != id3 {
+		t.Errorf("agentBeadID differs after cwd change: %q (original) vs %q (after chdir)", id1a, id3)
+	}
+}
+
 // Note: State persistence tests removed - state is now derived from beads assignee field.
 // Integration tests should verify beads-based state management.