fix(sling): accept bead IDs directly even when routing fails

When routing-based verification (verifyBeadExists) fails due to
routes.jsonl configuration issues, gt sling now falls back to pattern
matching via looksLikeBeadID to accept valid bead ID formats.

The fix ensures:
1. verifyBeadExists is tried first (routing-based lookup)
2. verifyFormulaExists is tried second (formula check)
3. looksLikeBeadID pattern match is used as final fallback

Also improved looksLikeBeadID to accept any 1-5 letter lowercase
prefix followed by hyphen and alphanumeric chars.

Fixes: gt sling bd-xxx failing with "not a valid bead or formula"
when the bead exists but routing cannot find it.

Closes: gt-9e8s5

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

internal/cmd/handoff.go

@@ -620,16 +620,37 @@ func sendHandoffMail(subject, message string) (string, error) {
 }
 
 // looksLikeBeadID checks if a string looks like a bead ID.
-// Bead IDs have format: prefix-xxxx where prefix is 2+ letters and xxxx is alphanumeric.
+// Bead IDs have format: prefix-xxxx where prefix is 1-5 lowercase letters and xxxx is alphanumeric.
+// Examples: "gt-abc123", "bd-ka761", "hq-cv-abc", "beads-xyz", "ap-qtsup.16"
 func looksLikeBeadID(s string) bool {
-	// Common bead prefixes
+	// Find the first hyphen
-	prefixes := []string{"gt-", "hq-", "bd-", "beads-"}
+	idx := strings.Index(s, "-")
-	for _, p := range prefixes {
+	if idx < 1 || idx > 5 {
-		if strings.HasPrefix(s, p) {
+		// No hyphen, or prefix is empty/too long
-			return true
+		return false
+	}
+
+	// Check prefix is all lowercase letters
+	prefix := s[:idx]
+	for _, c := range prefix {
+		if c < 'a' || c > 'z' {
+			return false
 		}
 	}
-	return false
+
+	// Check there's something after the hyphen
+	rest := s[idx+1:]
+	if len(rest) == 0 {
+		return false
+	}
+
+	// Check rest starts with alphanumeric and contains only alphanumeric, dots, hyphens
+	first := rest[0]
+	if !((first >= 'a' && first <= 'z') || (first >= '0' && first <= '9')) {
+		return false
+	}
+
+	return true
 }
 
 // hookBeadForHandoff attaches a bead to the current agent's hook.

internal/cmd/sling.go

@@ -210,16 +210,23 @@ func runSling(cmd *cobra.Command, args []string) error {
 
 		// Try as bead first
 		if err := verifyBeadExists(firstArg); err == nil {
-			// It's a bead
+			// It's a verified bead
 			beadID = firstArg
 		} else {
-			// Not a bead - try as standalone formula
+			// Not a verified bead - try as standalone formula
 			if err := verifyFormulaExists(firstArg); err == nil {
 				// Standalone formula mode: gt sling <formula> [target]
 				return runSlingFormula(args)
 			}
-			// Neither bead nor formula
+			// Not a formula either - check if it looks like a bead ID (routing issue workaround).
-			return fmt.Errorf("'%s' is not a valid bead or formula", firstArg)
+			// Accept it and let the actual bd update fail later if the bead doesn't exist.
+			// This fixes: gt sling bd-ka761 beads/crew/dave failing with 'not a valid bead or formula'
+			if looksLikeBeadID(firstArg) {
+				beadID = firstArg
+			} else {
+				// Neither bead nor formula
+				return fmt.Errorf("'%s' is not a valid bead or formula", firstArg)
+			}
 		}
 	}
 

internal/cmd/sling_test.go

@@ -503,3 +503,55 @@ exit 0
 		}
 	}
 }
+
+// TestLooksLikeBeadID tests the bead ID pattern recognition function.
+// This ensures gt sling accepts bead IDs even when routing-based verification fails.
+// Fixes: gt sling bd-ka761 failing with 'not a valid bead or formula'
+//
+// Note: looksLikeBeadID is a fallback check in sling. The actual sling flow is:
+// 1. Try verifyBeadExists (routing-based lookup)
+// 2. Try verifyFormulaExists (formula check)
+// 3. Fall back to looksLikeBeadID pattern match
+// So "mol-release" matches the pattern but won't be treated as bead in practice
+// because it would be caught by formula verification first.
+func TestLooksLikeBeadID(t *testing.T) {
+	tests := []struct {
+		input string
+		want  bool
+	}{
+		// Valid bead IDs - should return true
+		{"gt-abc123", true},
+		{"bd-ka761", true},
+		{"hq-cv-abc", true},
+		{"ap-qtsup.16", true},
+		{"beads-xyz", true},
+		{"jv-v599", true},
+		{"gt-9e8s5", true},
+		{"hq-00gyg", true},
+
+		// Short prefixes that match pattern (but may be formulas in practice)
+		{"mol-release", true},    // 3-char prefix matches pattern (formula check runs first in sling)
+		{"mol-abc123", true},     // 3-char prefix matches pattern
+
+		// Non-bead strings - should return false
+		{"formula-name", false},  // "formula" is 7 chars (> 5)
+		{"mayor", false},         // no hyphen
+		{"gastown", false},       // no hyphen
+		{"deacon/dogs", false},   // contains slash
+		{"", false},              // empty
+		{"-abc", false},          // starts with hyphen
+		{"GT-abc", false},        // uppercase prefix
+		{"123-abc", false},       // numeric prefix
+		{"a-", false},            // nothing after hyphen
+		{"aaaaaa-b", false},      // prefix too long (6 chars)
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.input, func(t *testing.T) {
+			got := looksLikeBeadID(tt.input)
+			if got != tt.want {
+				t.Errorf("looksLikeBeadID(%q) = %v, want %v", tt.input, got, tt.want)
+			}
+		})
+	}
+}