Add cross-project-aware ID generation to Store

Add generateUniqueIDExcluding and CreateExcluding to the store layer.
CreateExcluding generates IDs that are collision-free within both the
local store and an external exclusion set, enabling cross-project ID
uniqueness. Create delegates to CreateExcluding with a nil exclusion
set so all existing callers are unaffected.

Built with Raymond (Agent Orchestrator)

Author: vector76

internal/store/store.go

@@ -142,16 +142,28 @@ func (s *Store) save() error {
 // At IDMaxLen, it retries indefinitely.
 // Caller must hold s.mu.
 func (s *Store) generateUniqueID() string {
+	return s.generateUniqueIDExcluding(nil)
+}
+
+// generateUniqueIDExcluding creates a collision-free bead ID, also excluding
+// any IDs in the provided set (used for cross-project uniqueness).
+// Same retry/length-escalation logic as generateUniqueID.
+// Caller must hold s.mu.
+func (s *Store) generateUniqueIDExcluding(excluded map[string]struct{}) string {
 	for n := model.IDMinLen; n <= model.IDMaxLen; n++ {
 		retries := 3
 		if n == model.IDMaxLen {
 			retries = 100 // effectively unlimited at max length
 		}
 		for i := 0; i < retries; i++ {
 			id := model.GenerateIDN(n)
-			if _, exists := s.beads[id]; !exists {
-				return id
+			if _, exists := s.beads[id]; exists {
+				continue
 			}
+			if _, inExcluded := excluded[id]; inExcluded {
+				continue
+			}
+			return id
 		}
 	}
 	// Should never reach here given 36^8 possible IDs.
@@ -161,11 +173,18 @@ func (s *Store) generateUniqueID() string {
 // Create adds a bead to the store and persists to disk.
 // If b.ID is empty, a collision-free ID is generated automatically.
 func (s *Store) Create(b model.Bead) (model.Bead, error) {
+	return s.CreateExcluding(b, nil)
+}
+
+// CreateExcluding adds a bead to the store and persists to disk.
+// If b.ID is empty, a collision-free ID is generated that is also absent from
+// the excluded set, enabling cross-project uniqueness.
+func (s *Store) CreateExcluding(b model.Bead, excluded map[string]struct{}) (model.Bead, error) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 
 	if b.ID == "" {
-		b.ID = s.generateUniqueID()
+		b.ID = s.generateUniqueIDExcluding(excluded)
 	} else if _, exists := s.beads[b.ID]; exists {
 		return model.Bead{}, fmt.Errorf("bead %s already exists", b.ID)
 	}

internal/store/store_test.go

@@ -475,6 +475,88 @@ func TestLoadMigratesMixedStatuses(t *testing.T) {
 	}
 }
 
+// --- CreateExcluding tests ---
+
+func TestCreateExcludingNeverReturnsExcludedID(t *testing.T) {
+	s, _ := Load(tempPath(t))
+
+	// Build a large exclusion set using IDs in the typical generated format.
+	excluded := map[string]struct{}{
+		"bd-aaaa": {},
+		"bd-bbbb": {},
+		"bd-cccc": {},
+		"bd-dddd": {},
+		"bd-eeee": {},
+	}
+
+	for i := 0; i < 50; i++ {
+		b := model.NewBead("Excluded test")
+		created, err := s.CreateExcluding(b, excluded)
+		if err != nil {
+			t.Fatalf("iteration %d: unexpected error: %v", i, err)
+		}
+		if _, found := excluded[created.ID]; found {
+			t.Fatalf("iteration %d: returned excluded ID %q", i, created.ID)
+		}
+	}
+}
+
+func TestCreateExcludingWithNilExclusionSetBehavesLikeCreate(t *testing.T) {
+	s, _ := Load(tempPath(t))
+
+	b := model.NewBead("Nil exclusion")
+	created, err := s.CreateExcluding(b, nil)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if created.ID == "" {
+		t.Fatal("expected non-empty ID")
+	}
+
+	// Verify it is retrievable.
+	got, err := s.Get(created.ID)
+	if err != nil {
+		t.Fatalf("unexpected error getting bead: %v", err)
+	}
+	if got.Title != "Nil exclusion" {
+		t.Errorf("expected title 'Nil exclusion', got %q", got.Title)
+	}
+}
+
+func TestCreateExcludingWithEmptyExclusionSetBehavesLikeCreate(t *testing.T) {
+	s, _ := Load(tempPath(t))
+
+	b := model.NewBead("Empty exclusion")
+	created, err := s.CreateExcluding(b, map[string]struct{}{})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if created.ID == "" {
+		t.Fatal("expected non-empty ID")
+	}
+}
+
+func TestCreateStillWorksAfterRefactor(t *testing.T) {
+	s, _ := Load(tempPath(t))
+
+	b := model.NewBead("Create regression")
+	created, err := s.Create(b)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if created.ID == "" {
+		t.Fatal("expected non-empty ID after Create")
+	}
+
+	got, err := s.Get(created.ID)
+	if err != nil {
+		t.Fatalf("unexpected error getting bead: %v", err)
+	}
+	if got.Title != "Create regression" {
+		t.Errorf("expected title 'Create regression', got %q", got.Title)
+	}
+}
+
 func TestAtomicWriteFileExists(t *testing.T) {
 	path := tempPath(t)
 	s, err := Load(path)