Agent tools: plant lookup, plant creation, journal entries (#55) (#69)

Co-authored-by: Steve Dudenhoeffer <[email protected]>

internal/agent/tools.go

@@ -36,11 +36,36 @@ func NewToolbox(svc *service.Service, actorID int64) *llm.Toolbox {
 			"Place one plop of a plant inside a plantable object, positioned in the object's LOCAL frame (0,0 = object center, -y = north).",
 			a.placePlanting),
 		llm.DefineTool("fill_region",
-			"Fill a named region of a plantable object with a plant, hex-packed. Region is one of nw/ne/sw/se (corners), north/south/east/west or top/bottom/left/right (halves), or all.",
+			"Fill part of a plantable object with one plant, hex-packed at the plant's spacing. "+
+				"region is a compass name, not coordinates: nw|ne|sw|se for the quarter corners, "+
+				"north|south|east|west (or top|bottom|left|right) for halves, or all for the whole thing. "+
+				"North is the top of the garden. Example: to replant a whole bed, clear_object then "+
+				"fill_region with region=all. Filling skips spots already covered by an existing plant, "+
+				"so it is safe to run twice.",
 			a.fillRegion),
 		llm.DefineTool("clear_object",
-			"Remove all plants from an object (soft-remove; history is kept).",
+			"Remove all plants from an object. They are soft-removed, so the planting history for past "+
+				"seasons is kept and the change can be undone. Use this before replanting a bed with "+
+				"something else.",
 			a.clearObject),
+		llm.DefineTool("find_plant",
+			"Look up plants in the user's catalog by name or category, to get the plantId that "+
+				"place_planting and fill_region need. Returns SEVERAL candidates when the query is "+
+				"ambiguous — \"garlic\" may match both the built-in \"Garlic\" and a custom \"German Red "+
+				"Garlic\" — so pick the one that fits what the user asked for, or ask them which. Each "+
+				"result also reports how much seed the user has left of it, when they have recorded any.",
+			a.findPlant),
+		llm.DefineTool("create_plant",
+			"Add a new plant to the user's own catalog, for when they name a variety that isn't in it "+
+				"yet. Check find_plant first — creating a duplicate of something that already exists is "+
+				"worse than reusing it. The plant belongs to the user, not to any garden.",
+			a.createPlant),
+		llm.DefineTool("add_journal_entry",
+			"Write a dated observation into the garden's grow journal — what happened, and when. "+
+				"Attach it to one bed with objectId when it is about that bed. This is for events "+
+				"(\"powdery mildew on the west bed\", \"first frost\"), not for descriptions of what a "+
+				"thing is. observedAt defaults to today; set it to backdate.",
+			a.addJournalEntry),
 	)
 }
 
@@ -108,6 +133,42 @@ func (a *adapter) fillRegion(ctx context.Context, args struct {
 	return a.svc.FillNamedRegion(ctx, a.actor, args.ObjectID, args.Region, args.PlantID, args.SpacingOverride)
 }
 
+func (a *adapter) findPlant(ctx context.Context, args struct {
+	Query string `json:"query" description:"plant name or category to search for, e.g. \"cucumber\" or \"herb\"; empty lists the catalog"`
+}) (any, error) {
+	return a.svc.FindPlants(ctx, a.actor, args.Query)
+}
+
+func (a *adapter) createPlant(ctx context.Context, args struct {
+	Name           string  `json:"name" description:"the variety's name, e.g. \"German Red Garlic\""`
+	Category       string  `json:"category" description:"vegetable | herb | flower | fruit | tree_shrub | cover"`
+	SpacingCM      float64 `json:"spacingCm" description:"mature in-row spacing in cm; this is what fill_region packs to"`
+	Color          string  `json:"color" description:"hex color for the plant on the canvas, e.g. #8a5a8a"`
+	Icon           string  `json:"icon" description:"a single emoji to draw it with, e.g. 🧄"`
+	DaysToMaturity *int    `json:"daysToMaturity" description:"optional days from planting to harvest"`
+	SourceURL      string  `json:"sourceUrl" description:"optional http(s) link to where the seed came from"`
+	Vendor         string  `json:"vendor" description:"optional vendor name, e.g. \"Johnny\u0027s Selected Seeds\""`
+}) (any, error) {
+	return a.svc.CreatePlant(ctx, a.actor, service.PlantInput{
+		Name: args.Name, Category: args.Category, SpacingCM: args.SpacingCM,
+		Color: args.Color, Icon: args.Icon, DaysToMaturity: args.DaysToMaturity,
+		SourceURL: args.SourceURL, Vendor: args.Vendor,
+	})
+}
+
+func (a *adapter) addJournalEntry(ctx context.Context, args struct {
+	GardenID   int64  `json:"gardenId" description:"garden the observation is about"`
+	ObjectID   *int64 `json:"objectId" description:"optional bed the observation is about; omit for a garden-level note"`
+	Body       string `json:"body" description:"what happened, in plain words"`
+	ObservedAt string `json:"observedAt" description:"optional date it happened, YYYY-MM-DD; defaults to today"`
+}) (any, error) {
+	in := service.JournalInput{ObjectID: args.ObjectID, Body: args.Body}
+	if args.ObservedAt != "" {
+		in.ObservedAt = &args.ObservedAt
+	}
+	return a.svc.CreateJournalEntry(ctx, a.actor, args.GardenID, in)
+}
+
 func (a *adapter) clearObject(ctx context.Context, args struct {
 	ObjectID int64 `json:"objectId" description:"object to remove all plants from"`
 }) (any, error) {

internal/agent/tools_test.go

@@ -5,6 +5,7 @@ package agent
 import (
 	"context"
 	"encoding/json"
+	"strings"
 	"testing"
 
 	"gitea.stevedudenhoeffer.com/steve/majordomo/llm"
@@ -24,21 +25,8 @@ import (
 // Build/run with: go test -tags majordomo ./internal/agent/
 func TestToolboxScenario(t *testing.T) {
 	ctx := context.Background()
-	db, err := store.Open(":memory:")
-	if err != nil {
-		t.Fatalf("open: %v", err)
-	}
-	t.Cleanup(func() { db.Close() })
-	if err := db.Migrate(ctx); err != nil {
-		t.Fatalf("migrate: %v", err)
-	}
-	svc := service.New(db, &config.Config{Registration: config.RegistrationOpen, LocalAuth: true})
-
-	owner, err := svc.Register(ctx, service.RegisterInput{Email: "[email protected]", DisplayName: "A", Password: "password123"})
-	if err != nil {
-		t.Fatalf("register: %v", err)
-	}
-	box := NewToolbox(svc, owner.ID)
+	svc, ownerID := newAgentTestService(t)
+	box := NewToolbox(svc, ownerID)
 
 	call := func(name string, args any) llm.ToolResult {
 		t.Helper()
@@ -48,13 +36,13 @@ func TestToolboxScenario(t *testing.T) {
 
 	// Garden + plants are set up directly (there are no create_garden/plant tools);
 	// the agent-facing bits — object + fills + describe — go through the toolbox.
-	g, err := svc.CreateGarden(ctx, owner.ID, service.GardenInput{Name: "Plot", WidthCM: 2000, HeightCM: 2000})
+	g, err := svc.CreateGarden(ctx, ownerID, service.GardenInput{Name: "Plot", WidthCM: 2000, HeightCM: 2000})
 	if err != nil {
 		t.Fatalf("garden: %v", err)
 	}
-	garlic := mustPlant(t, svc, owner.ID, "Garlic", 15, "🧄")
-	basil := mustPlant(t, svc, owner.ID, "Basil", 25, "🌿")
-	beans := mustPlant(t, svc, owner.ID, "Beans", 10, "🫘")
+	garlic := mustPlant(t, svc, ownerID, "Garlic", 15, "🧄")
+	basil := mustPlant(t, svc, ownerID, "Basil", 25, "🌿")
+	beans := mustPlant(t, svc, ownerID, "Beans", 10, "🫘")
 
 	// create_object → a 400×400 bed.
 	res := call("create_object", map[string]any{
@@ -119,7 +107,7 @@ func TestToolboxScenario(t *testing.T) {
 	if err != nil {
 		t.Fatalf("register viewer: %v", err)
 	}
-	if _, err := svc.AddShare(ctx, owner.ID, g.ID, "[email protected]", domain.RoleViewer); err != nil {
+	if _, err := svc.AddShare(ctx, ownerID, g.ID, "[email protected]", domain.RoleViewer); err != nil {
 		t.Fatalf("share: %v", err)
 	}
 	viewerBox := NewToolbox(svc, viewerUser.ID)
@@ -150,3 +138,233 @@ func mustPlant(t *testing.T, svc *service.Service, owner int64, name string, spa
 	}
 	return p
 }
+
+// TestGarlicBedToCucumbers is the flagship interaction from #58, driven end to
+// end through the tool layer: "change the garlic garden bed to instead be
+// cucumbers this year".
+//
+// The sequence is the one a model would actually run — describe to find the bed,
+// find_plant to turn the word "cucumber" into an id, clear, refill — and until
+// find_plant existed step three had no way to get its plantId, which blocked the
+// whole thing on one missing tool.
+func TestGarlicBedToCucumbers(t *testing.T) {
+	ctx := context.Background()
+	svc, owner := newAgentTestService(t)
+	box := NewToolbox(svc, owner)
+
+	call := func(name string, args any) llm.ToolResult {
+		t.Helper()
+		raw, _ := json.Marshal(args)
+		return box.Execute(ctx, llm.ToolCall{ID: "1", Name: name, Arguments: raw})
+	}
+
+	g, err := svc.CreateGarden(ctx, owner, service.GardenInput{Name: "Plot", WidthCM: 2000, HeightCM: 2000})
+	if err != nil {
+		t.Fatalf("garden: %v", err)
+	}
+	garlic := mustPlant(t, svc, owner, "Garlic", 15, "🧄")
+	mustPlant(t, svc, owner, "Cucumber", 45, "🥒")
+
+	bed, err := svc.CreateObject(ctx, owner, g.ID, service.ObjectInput{
+		Kind: domain.KindBed, Name: "Garlic bed", XCM: 1000, YCM: 1000, WidthCM: 400, HeightCM: 400,
+	})
+	if err != nil {
+		t.Fatalf("bed: %v", err)
+	}
+	if _, err := svc.FillNamedRegion(ctx, owner, bed.ID, "all", garlic.ID, nil); err != nil {
+		t.Fatalf("seed the garlic: %v", err)
+	}
+
+	// 1. describe_garden — "the garlic bed" resolves to an object id, because the
+	//    description carries the NAMES of what's planted in each object.
+	res := call("describe_garden", map[string]any{"gardenId": g.ID})
+	if res.IsError {
+		t.Fatalf("describe_garden: %s", res.Content)
+	}
+	if !strings.Contains(res.Content, "Garlic") {
+		t.Fatalf("describe_garden didn't name what's planted: %s", res.Content)
+	}
+
+	// 2. find_plant — the step that used to be impossible.
+	res = call("find_plant", map[string]any{"query": "cucumber"})
+	if res.IsError {
+		t.Fatalf("find_plant: %s", res.Content)
+	}
+	var matches []struct {
+		ID   int64  `json:"id"`
+		Name string `json:"name"`
+	}
+	if err := json.Unmarshal([]byte(res.Content), &matches); err != nil {
+		t.Fatalf("decode find_plant: %v (%s)", err, res.Content)
+	}
+	if len(matches) == 0 || matches[0].Name != "Cucumber" {
+		t.Fatalf("find_plant(cucumber) = %+v", matches)
+	}
+
+	// 3. clear_object, 4. fill_region.
+	if r := call("clear_object", map[string]any{"objectId": bed.ID}); r.IsError {
+		t.Fatalf("clear_object: %s", r.Content)
+	}
+	if r := call("fill_region", map[string]any{
+		"objectId": bed.ID, "region": "all", "plantId": matches[0].ID,
+	}); r.IsError {
+		t.Fatalf("fill_region: %s", r.Content)
+	}
+
+	// The bed is cucumbers, and no garlic is still growing in it.
+	full, err := svc.GardenFull(ctx, owner, g.ID, nil)
+	if err != nil {
+		t.Fatalf("GardenFull: %v", err)
+	}
+	if len(full.Plantings) == 0 {
+		t.Fatal("the bed ended up empty")
+	}
+	for _, p := range full.Plantings {
+		if p.PlantID == garlic.ID {
+			t.Errorf("garlic is still active in the bed")
+		}
+		if p.PlantID != matches[0].ID {
+			t.Errorf("unexpected plant %d in the bed", p.PlantID)
+		}
+	}
+}
+
+// TestFindPlantReturnsCandidatesNotAGuess — "garlic" against a catalog holding
+// both "Garlic" and "German Red Garlic" is genuinely ambiguous, and silently
+// picking one is how the agent plants the wrong thing.
+func TestFindPlantReturnsCandidatesNotAGuess(t *testing.T) {
+	ctx := context.Background()
+	svc, owner := newAgentTestService(t)
+	box := NewToolbox(svc, owner)
+
+	mustPlant(t, svc, owner, "German Red Garlic", 15, "🧄")
+
+	raw, _ := json.Marshal(map[string]any{"query": "garlic"})
+	res := box.Execute(ctx, llm.ToolCall{ID: "1", Name: "find_plant", Arguments: raw})
+	if res.IsError {
+		t.Fatalf("find_plant: %s", res.Content)
+	}
+	var matches []struct {
+		Name string `json:"name"`
+	}
+	if err := json.Unmarshal([]byte(res.Content), &matches); err != nil {
+		t.Fatalf("decode: %v", err)
+	}
+	names := map[string]bool{}
+	for _, m := range matches {
+		names[m.Name] = true
+	}
+	// The built-in catalog seeds a plain "Garlic"; the custom one is ours.
+	if !names["Garlic"] || !names["German Red Garlic"] {
+		t.Errorf("find_plant(garlic) = %+v, want both the built-in and the custom variety", matches)
+	}
+	// Exact match ranks first, so a caller taking [0] gets the least surprising one.
+	if len(matches) > 0 && matches[0].Name != "Garlic" {
+		t.Errorf("first match = %q, want the exact name", matches[0].Name)
+	}
+}
+
+// TestCreatePlantIsUserScoped — the catalog belongs to the user, not to any
+// garden, so someone with no editable garden can still name a new variety. The
+// issue asks for this to be asserted rather than assumed.
+func TestCreatePlantIsUserScoped(t *testing.T) {
+	ctx := context.Background()
+	svc, owner := newAgentTestService(t)
+	other, err := svc.Register(ctx, service.RegisterInput{Email: "[email protected]", DisplayName: "B", Password: "password123"})
+	if err != nil {
+		t.Fatalf("register: %v", err)
+	}
+	box := NewToolbox(svc, other.ID)
+
+	raw, _ := json.Marshal(map[string]any{
+		"name": "Painted Mountain Corn", "category": "vegetable",
+		"spacingCm": 30.0, "color": "#c08a3f", "icon": "🌽",
+	})
+	res := box.Execute(ctx, llm.ToolCall{ID: "1", Name: "create_plant", Arguments: raw})
+	if res.IsError {
+		t.Fatalf("create_plant: %s", res.Content)
+	}
+	var created struct {
+		ID      int64  `json:"id"`
+		OwnerID *int64 `json:"ownerId"`
+		Name    string `json:"name"`
+	}
+	if err := json.Unmarshal([]byte(res.Content), &created); err != nil {
+		t.Fatalf("decode: %v", err)
+	}
+	if created.OwnerID == nil || *created.OwnerID != other.ID {
+		t.Errorf("ownerId = %v, want the acting user %d", created.OwnerID, other.ID)
+	}
+	// And it stays theirs: the other user's catalog doesn't gain it.
+	ownerPlants, err := svc.ListPlants(ctx, owner)
+	if err != nil {
+		t.Fatalf("ListPlants: %v", err)
+	}
+	for _, p := range ownerPlants {
+		if p.Name == "Painted Mountain Corn" {
+			t.Error("a plant created by one user showed up in another's catalog")
+		}
+	}
+}
+
+// TestJournalToolWritesADatedObservation — "note that the west bed has mildew"
+// is squarely the kind of thing you say out loud while walking around.
+func TestJournalToolWritesADatedObservation(t *testing.T) {
+	ctx := context.Background()
+	svc, owner := newAgentTestService(t)
+	box := NewToolbox(svc, owner)
+
+	g, err := svc.CreateGarden(ctx, owner, service.GardenInput{Name: "Plot", WidthCM: 2000, HeightCM: 2000})
+	if err != nil {
+		t.Fatalf("garden: %v", err)
+	}
+	bed, err := svc.CreateObject(ctx, owner, g.ID, service.ObjectInput{
+		Kind: domain.KindBed, Name: "West bed", XCM: 500, YCM: 500, WidthCM: 200, HeightCM: 200,
+	})
+	if err != nil {
+		t.Fatalf("bed: %v", err)
+	}
+
+	raw, _ := json.Marshal(map[string]any{
+		"gardenId": g.ID, "objectId": bed.ID,
+		"body": "Powdery mildew on the west bed", "observedAt": "2026-08-14",
+	})
+	res := box.Execute(ctx, llm.ToolCall{ID: "1", Name: "add_journal_entry", Arguments: raw})
+	if res.IsError {
+		t.Fatalf("add_journal_entry: %s", res.Content)
+	}
+
+	entries, _, err := svc.ListJournal(ctx, owner, g.ID, service.JournalQuery{ObjectID: &bed.ID})
+	if err != nil {
+		t.Fatalf("ListJournal: %v", err)
+	}
+	if len(entries) != 1 {
+		t.Fatalf("got %d entries, want 1", len(entries))
+	}
+	if entries[0].Body != "Powdery mildew on the west bed" || entries[0].ObservedAt != "2026-08-14" {
+		t.Errorf("unexpected entry: %+v", entries[0])
+	}
+	if entries[0].AuthorID != owner {
+		t.Errorf("author = %d, want the acting user %d", entries[0].AuthorID, owner)
+	}
+}
+
+// newAgentTestService spins up an in-memory pansy with one registered user.
+func newAgentTestService(t *testing.T) (*service.Service, int64) {
+	t.Helper()
+	ctx := context.Background()
+	db, err := store.Open(":memory:")
+	if err != nil {
+		t.Fatalf("open: %v", err)
+	}
+	t.Cleanup(func() { db.Close() })
+	if err := db.Migrate(ctx); err != nil {
+		t.Fatalf("migrate: %v", err)
+	}
+	svc := service.New(db, &config.Config{Registration: config.RegistrationOpen, LocalAuth: true})
+	owner, err := svc.Register(ctx, service.RegisterInput{Email: "[email protected]", DisplayName: "A", Password: "password123"})
+	if err != nil {
+		t.Fatalf("register: %v", err)
+	}
+	return svc, owner.ID
+}

internal/service/plants.go

@@ -2,6 +2,7 @@ package service
 
 import (
 	"context"
+	"sort"
 	"strings"
 
 	"gitea.stevedudenhoeffer.com/steve/pansy/internal/domain"
@@ -69,6 +70,124 @@ func (s *Service) ListPlants(ctx context.Context, actorID int64) ([]domain.Plant
 	return s.store.ListPlantsForActor(ctx, actorID)
 }
 
+// PlantMatch is a candidate from FindPlants: the plant, plus what seed the actor
+// has left of it, so an agent can say "you only have enough for half that bed"
+// instead of confidently planting seed that doesn't exist.
+type PlantMatch struct {
+	domain.Plant
+	// SeedRemaining is the total left across the actor's lots of this plant, and
+	// SeedUnit the unit they're counted in. Both are omitted when there are no
+	// lots — and also when the lots disagree about the unit, because adding
+	// grams to packets produces a number that means nothing. SeedLots still
+	// reports how many there are, so "several lots, no single total" is
+	// distinguishable from "no seed at all".
+	SeedRemaining *float64 `json:"seedRemaining,omitempty"`
+	SeedUnit      string   `json:"seedUnit,omitempty"`
+	SeedLots      int      `json:"seedLots,omitempty"`
+}
+
+// maxPlantMatches caps FindPlants. A model given fifty candidates is not being
+// helped; if the query is that broad the answer is to ask a better one.
+const maxPlantMatches = 10
+
+// FindPlants returns the plants in the actor's visible catalog (built-ins plus
+// their own) whose name or category matches the query, best match first.
+//
+// It deliberately returns SEVERAL candidates rather than one guess. "garlic"
+// against a catalog holding both "Garlic" and "German Red Garlic" is genuinely
+// ambiguous, and a caller with the surrounding conversation is far better placed
+// to disambiguate than a fuzzy-match heuristic here. An empty query returns the
+// catalog head rather than nothing, so a caller can browse.
+func (s *Service) FindPlants(ctx context.Context, actorID int64, query string) ([]PlantMatch, error) {
+	plants, err := s.store.ListPlantsForActor(ctx, actorID)
+	if err != nil {
+		return nil, err
+	}
+	q := strings.ToLower(strings.TrimSpace(query))
+
+	type scored struct {
+		plant domain.Plant
+		rank  int
+	}
+	ranked := make([]scored, 0, len(plants))
+	for _, p := range plants {
+		name := strings.ToLower(p.Name)
+		switch {
+		case q == "":
+			ranked = append(ranked, scored{p, 3})
+		case name == q:
+			ranked = append(ranked, scored{p, 0})
+		case strings.HasPrefix(name, q):
+			ranked = append(ranked, scored{p, 1})
+		case strings.Contains(name, q):
+			ranked = append(ranked, scored{p, 2})
+		case strings.Contains(strings.ToLower(p.Category), q):
+			ranked = append(ranked, scored{p, 3})
+		}
+	}
+	// Stable by rank then name, so the same query always answers the same way —
+	// a tool whose results reshuffle between calls is one a model can't reason
+	// about across turns.
+	sort.SliceStable(ranked, func(i, j int) bool {
+		if ranked[i].rank != ranked[j].rank {
+			return ranked[i].rank < ranked[j].rank
+		}
+		return ranked[i].plant.Name < ranked[j].plant.Name
+	})
+	if len(ranked) > maxPlantMatches {
+		ranked = ranked[:maxPlantMatches]
+	}
+
+	matches := make([]PlantMatch, 0, len(ranked))
+	for _, r := range ranked {
+		matches = append(matches, PlantMatch{Plant: r.plant})
+	}
+	if err := s.attachSeedRemaining(ctx, actorID, matches); err != nil {
+		return nil, err
+	}
+	return matches, nil
+}
+
+// attachSeedRemaining fills SeedRemaining/SeedUnit from the actor's lots.
+func (s *Service) attachSeedRemaining(ctx context.Context, actorID int64, matches []PlantMatch) error {
+	if len(matches) == 0 {
+		return nil
+	}
+	lots, err := s.ListSeedLots(ctx, actorID, nil)
+	if err != nil {
+		return err
+	}
+	byPlant := map[int64][]domain.SeedLot{}
+	for _, l := range lots {
+		byPlant[l.PlantID] = append(byPlant[l.PlantID], l)
+	}
+	for i := range matches {
+		ls := byPlant[matches[i].ID]
+		if len(ls) == 0 {
+			continue
+		}
+		matches[i].SeedLots = len(ls)
+		unit := ls[0].Unit
+		mixed := false
+		total := 0.0
+		for _, l := range ls {
+			total += l.Remaining
+			if l.Unit != unit {
+				mixed = true
+			}
+		}
+		if mixed {
+			// Dropping only the LABEL would leave a number that reads as a
+			// quantity and isn't one. Drop the total with it; SeedLots still says
+			// there is seed here, just not one figure for it.
+			continue
+		}
+		matches[i].SeedRemaining = &total
+		matches[i].SeedUnit = unit
+	}
+	return nil
+}
+
 // CreatePlant adds a plant owned by the actor. To "clone" a built-in the client
 // simply POSTs a copy — there is no dedicated endpoint, and the copy is owned by
 // (and editable by) the actor.

internal/service/plants_test.go

@@ -237,3 +237,138 @@ func TestDeletePlantInUseIsBlocked(t *testing.T) {
 		t.Errorf("delete freed plant: %v", err)
 	}
 }
+
+// TestFindPlantsRanksAndDisambiguates — FindPlants deliberately returns several
+// candidates rather than one guess, because "garlic" against a catalog holding
+// both "Garlic" and "German Red Garlic" is genuinely ambiguous and a caller with
+// the surrounding context is better placed to choose than a heuristic here.
+func TestFindPlantsRanksAndDisambiguates(t *testing.T) {
+	s := newTestService(t, openConfig())
+	owner := seedUser(t, s, "[email protected]")
+	ctx := context.Background()
+
+	custom, err := s.CreatePlant(ctx, owner, PlantInput{
+		Name: "German Red Garlic", Category: domain.CategoryVegetable, SpacingCM: 15,
+		Color: "#8a5a8a", Icon: "🧄",
+	})
+	if err != nil {
+		t.Fatalf("CreatePlant: %v", err)
+	}
+
+	got, err := s.FindPlants(ctx, owner, "garlic")
+	if err != nil {
+		t.Fatalf("FindPlants: %v", err)
+	}
+	names := map[string]bool{}
+	for _, m := range got {
+		names[m.Name] = true
+	}
+	if !names["Garlic"] || !names[custom.Name] {
+		t.Errorf("got %v, want both the built-in and the custom variety", names)
+	}
+	// Exact match first, so a caller taking [0] gets the least surprising one.
+	if got[0].Name != "Garlic" {
+		t.Errorf("first match = %q, want the exact name", got[0].Name)
+	}
+
+	// Prefix beats substring: "german" should surface the custom one first.
+	pre, err := s.FindPlants(ctx, owner, "german")
+	if err != nil {
+		t.Fatalf("FindPlants: %v", err)
+	}
+	if len(pre) == 0 || pre[0].Name != custom.Name {
+		t.Errorf("FindPlants(german) = %+v, want the custom variety first", pre)
+	}
+
+	// Category search works, and a query matching nothing says so plainly.
+	if herbs, _ := s.FindPlants(ctx, owner, "herb"); len(herbs) == 0 {
+		t.Error("category search found nothing")
+	}
+	if none, _ := s.FindPlants(ctx, owner, "zzzzz"); len(none) != 0 {
+		t.Errorf("FindPlants(zzzzz) = %+v, want nothing", none)
+	}
+}
+
+// TestFindPlantsReportsSeedRemaining — so a caller can say "you only have enough
+// for half that bed" instead of confidently planting seed that doesn't exist.
+func TestFindPlantsReportsSeedRemaining(t *testing.T) {
+	s := newTestService(t, openConfig())
+	owner := seedUser(t, s, "[email protected]")
+	other := seedUser(t, s, "[email protected]")
+	ctx := context.Background()
+
+	plant := seedOwnPlant(t, s, owner, 15)
+	if _, err := s.CreateSeedLot(ctx, owner, SeedLotInput{
+		PlantID: plant.ID, Quantity: 100, Unit: domain.UnitSeeds,
+	}); err != nil {
+		t.Fatalf("CreateSeedLot: %v", err)
+	}
+
+	got, err := s.FindPlants(ctx, owner, plant.Name)
+	if err != nil {
+		t.Fatalf("FindPlants: %v", err)
+	}
+	if len(got) == 0 || got[0].SeedRemaining == nil || *got[0].SeedRemaining != 100 {
+		t.Fatalf("seedRemaining = %+v, want 100", got[0].SeedRemaining)
+	}
+	if got[0].SeedUnit != domain.UnitSeeds {
+		t.Errorf("seedUnit = %q", got[0].SeedUnit)
+	}
+
+	// A plant with no lots reports nothing rather than a misleading zero.
+	builtin, err := s.FindPlants(ctx, owner, "Garlic")
+	if err != nil {
+		t.Fatalf("FindPlants: %v", err)
+	}
+	if len(builtin) > 0 && builtin[0].SeedRemaining != nil {
+		t.Errorf("a plant with no lots reported %v remaining", *builtin[0].SeedRemaining)
+	}
+
+	// And lots are private: another user searching the same plant sees no seed.
+	// (They can't see the custom plant at all, so search a built-in instead.)
+	if _, err := s.CreateSeedLot(ctx, other, SeedLotInput{
+		PlantID: builtinPlantID(t, s, other), Quantity: 50, Unit: domain.UnitSeeds,
+	}); err != nil {
+		t.Fatalf("CreateSeedLot(other): %v", err)
+	}
+	mine, _ := s.FindPlants(ctx, owner, "Garlic")
+	for _, m := range mine {
+		if m.SeedRemaining != nil {
+			t.Errorf("saw another user's seed count on %q", m.Name)
+		}
+	}
+}
+
+// TestFindPlantsOmitsATotalItCannotHonestlyGive — lots in different units can't
+// be summed. Dropping only the unit LABEL would leave a number that reads as a
+// quantity and isn't one; the count of lots still says there is seed here.
+func TestFindPlantsOmitsATotalItCannotHonestlyGive(t *testing.T) {
+	s := newTestService(t, openConfig())
+	owner := seedUser(t, s, "[email protected]")
+	plant := seedOwnPlant(t, s, owner, 15)
+	ctx := context.Background()
+
+	for _, u := range []string{domain.UnitSeeds, domain.UnitGrams} {
+		if _, err := s.CreateSeedLot(ctx, owner, SeedLotInput{PlantID: plant.ID, Quantity: 50, Unit: u}); err != nil {
+			t.Fatalf("CreateSeedLot(%s): %v", u, err)
+		}
+	}
+
+	got, err := s.FindPlants(ctx, owner, plant.Name)
+	if err != nil {
+		t.Fatalf("FindPlants: %v", err)
+	}
+	if len(got) == 0 {
+		t.Fatal("plant not found")
+	}
+	if got[0].SeedRemaining != nil {
+		t.Errorf("reported %v across mismatched units; that number means nothing", *got[0].SeedRemaining)
+	}
+	if got[0].SeedUnit != "" {
+		t.Errorf("seedUnit = %q, want empty", got[0].SeedUnit)
+	}
+	// But "several lots, no single total" must stay distinguishable from "none".
+	if got[0].SeedLots != 2 {
+		t.Errorf("seedLots = %d, want 2", got[0].SeedLots)
+	}
+}