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

"Change the garlic garden bed to instead be cucumbers this year" was nearly
executable already — describe_garden resolves "the garlic bed" to an object id
because it reports the NAMES of what's planted, clear_object empties it, and
fill_region replants it. Step three had no way to get its plantId. The toolbox
had no plant tool at all, so the agent could see the string "Garlic" come out of
describe_garden and had no route from "cucumbers" to an id. One missing tool
blocked the whole flagship interaction.

find_plant matches the actor's visible catalog and 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 holding
the surrounding conversation is far better placed to disambiguate than a
fuzzy-match heuristic here. Results are ranked exact, then prefix, then
substring, then category, and ordered stably — a tool whose results reshuffle
between calls is one a model can't reason about across turns.

Each result also reports how much seed is left of that plant across the actor's
lots, so the agent can say "you only have enough for half that bed" instead of
confidently planting seed that doesn't exist. Omitted rather than zeroed when
there are no lots, and dropped when lots disagree about the unit, since summing
seeds and grams would be a lie.

create_plant lets a variety be named in conversation without leaving the chat.
It's user-scoped, not garden-scoped — someone with no editable garden can still
name a plant — which the tests assert deliberately rather than assume.

add_journal_entry arrived with #52: "note that the west bed has mildew" is
squarely the kind of thing you say out loud while walking around.

Also reviewed the descriptions on the existing seven tools, since they are the
model's only documentation. fill_region's region vocabulary now says north is
the top of the garden, gives a worked example of the replant sequence, and notes
that filling twice is safe.

The demo sequence is now a test: describe_garden → find_plant("cucumber") →
clear_object → fill_region, ending with a bed of cucumbers and no active garlic.

go.mod is deliberately untouched — majordomo stays out of the module until #56
drops the build tag, so the default build is unaffected.

Closes #55

Co-Authored-By: Claude Opus 4.8 (1M context) <[email protected]>
Claude-Session: https://claude.ai/code/session_01H3zbym8Doka2d7D48maSgZ

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"
@@ -150,3 +151,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,112 @@ 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 — omitted when there are no lots, or
+	// when lots disagree about the unit and summing them would be a lie.
+	SeedRemaining *float64 `json:"seedRemaining,omitempty"`
+	SeedUnit      string   `json:"seedUnit,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
+		}
+		total := 0.0
+		unit := ls[0].Unit
+		for _, l := range ls {
+			total += l.Remaining
+			if l.Unit != unit {
+				unit = "" // mixed units can't be summed honestly
+			}
+		}
+		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,104 @@ 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)
+		}
+	}
+}