pantrybase 0.1.0 → 0.3.0

package/dist/cli.js

@@ -12,7 +12,7 @@ import {
   resolveProjectRoot,
   searchRecipes,
   startUiServer
-} from "./chunk-2EMC6TJB.js";
+} from "./chunk-IUQQ3I2E.js";
 
 // src/cli.ts
 import { spawn } from "child_process";

package/dist/server.js

@@ -5,9 +5,11 @@ import {
   MODEL_MAX_PX,
   SOURCE_KINDS,
   addToPantry,
+  autofillPlan,
   availableIngredients,
   closeAllContexts,
   finalizeAttach,
+  getPlan,
   imageForModel,
   importPaths,
   listPantry,
@@ -26,14 +28,19 @@ import {
   recipeInputSchema,
   reconcile,
   removeFromPantry,
+  renderShoppingList,
   resolveItem,
   resolveItems,
+  rotateItem,
+  savePlan,
   scoreRecipes,
   searchRecipes,
+  shoppingList,
   startUiServer,
-  viewItem,
+  suggestRecipes,
+  viewItems,
   writeRecipeFile
-} from "./chunk-2EMC6TJB.js";
+} from "./chunk-IUQQ3I2E.js";
 
 // src/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -136,7 +143,7 @@ import path from "path";
 import { z as z3 } from "zod";
 var pb_inbox_image_default = defineTool({
   name: "pb_inbox_image",
-  description: "Show one queued (or archived) photo as an image, resized for reading (long edge \u2264 1600px by default; ask for up to 2400 if small print is unreadable). HEIC is converted automatically.",
+  description: "Show one queued (or archived) photo as an image, resized for reading (long edge \u2264 1600px by default; ask for up to 2400 if small print is unreadable). HEIC is converted automatically. If the text runs sideways or upside down, fix it with pb_inbox_rotate and look again.",
   schema: {
     id: z3.number().int(),
     max_px: z3.number().int().min(400).max(2400).optional()
@@ -175,7 +182,10 @@ var pb_inbox_list_default = defineTool({
   },
   handler: ({ status, limit, offset }, ctx) => {
     const items = ctx.store.listIngest({ status, limit: limit ?? 20, offset });
-    return text({ counts: ctx.store.ingestCounts(), items: items.map((i) => viewItem(i)) });
+    return text({
+      counts: ctx.store.ingestCounts(),
+      items: viewItems(items, ctx.store.allIngest())
+    });
   }
 });
 
@@ -183,7 +193,7 @@ var pb_inbox_list_default = defineTool({
 import { z as z5 } from "zod";
 var pb_inbox_next_default = defineTool({
   name: "pb_inbox_next",
-  description: "The next pending inbox photos in capture order, plus queue progress. Cards are usually shot front then back (a back has no title), so look at the photos in order with pb_inbox_image, group the ones that belong to one card, and save it with pb_save_recipe {ingest:[{id, side}]}. `retake_of` flags a near-identical photo: attach it as an extra image or skip it with pb_inbox_resolve.",
+  description: "The next pending inbox photos in capture order, plus queue progress. Cards are usually shot front then back (a back has no title), so look at the photos in order with pb_inbox_image, group the ones that belong to one card, and save it with pb_save_recipe {ingest:[{id, side}]}. `retake_of` flags a near-identical photo: attach it as an extra image or skip it with pb_inbox_resolve. `rotation_hint` flags a photo whose shape differs from the rest \u2014 rotate it with pb_inbox_rotate if it reads sideways.",
   schema: {
     window: z5.number().int().min(1).max(12).optional().describe("How many photos to return (default 4)")
   },
@@ -210,14 +220,26 @@ var pb_inbox_resolve_default = defineTool({
   }
 });
 
-// src/mcp/tools/pb_ingest_source.ts
+// src/mcp/tools/pb_inbox_rotate.ts
 import { z as z7 } from "zod";
+var pb_inbox_rotate_default = defineTool({
+  name: "pb_inbox_rotate",
+  description: "Turn a photo upright when its text runs sideways or upside down (camera orientation flags are already applied, so this is for photos whose pixels are rotated). Degrees are clockwise: text reading bottom-to-top needs 90, upside down needs 180, top-to-bottom needs 270. The file is fixed on disk (HEIC becomes JPEG), so the archive, thumbnails and retake detection all see the upright photo. Call before pb_inbox_image when pb_inbox_next gives a rotation_hint, or after a photo shows up sideways; view it again to confirm.",
+  schema: {
+    id: z7.number().int(),
+    degrees: z7.union([z7.literal(90), z7.literal(180), z7.literal(270)])
+  },
+  handler: async ({ id, degrees }, ctx) => text({ rotated: degrees, item: await rotateItem(ctx, id, degrees) })
+});
+
+// src/mcp/tools/pb_ingest_source.ts
+import { z as z8 } from "zod";
 var pb_ingest_source_default = defineTool({
   name: "pb_ingest_source",
   description: "Copy recipe photos (JPEG, PNG, WebP, HEIC, TIFF) from files or folders into pantrybase/inbox/ for extraction. Originals are never moved or changed; photos already known (same bytes) are skipped. Folders are searched recursively by default. Returns counts and the queue state; then work through it with pb_inbox_next.",
   schema: {
-    paths: z7.array(z7.string()).min(1).describe("Files or folders; relative to the project, absolute, or ~/\u2026"),
-    recursive: z7.boolean().optional()
+    paths: z8.array(z8.string()).min(1).describe("Files or folders; relative to the project, absolute, or ~/\u2026"),
+    recursive: z8.boolean().optional()
   },
   handler: async ({ paths, recursive }, ctx) => {
     const r = await importPaths(ctx, paths, { recursive });
@@ -234,13 +256,13 @@ var pb_ingest_source_default = defineTool({
 });
 
 // src/mcp/tools/pb_list_tags.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 var pb_list_tags_default = defineTool({
   name: "pb_list_tags",
   description: "Tags and facets in use, with recipe counts, grouped by category. With vocabulary:true also returns the allowed vocabulary (closed categories list every value). Call once before a batch of saves and reuse existing values.",
   schema: {
-    category: z8.enum(ALL_CATEGORIES).optional(),
-    vocabulary: z8.boolean().optional()
+    category: z9.enum(ALL_CATEGORIES).optional(),
+    vocabulary: z9.boolean().optional()
   },
   handler: ({ category, vocabulary }, ctx) => {
     const used = {};
@@ -259,7 +281,7 @@ var pb_list_tags_default = defineTool({
 });
 
 // src/mcp/tools/pb_merge_ingredients.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 
 // src/ingredients/merge.ts
 import fs from "fs";
@@ -363,8 +385,8 @@ var pb_merge_ingredients_default = defineTool({
   name: "pb_merge_ingredients",
   description: "Merge an ingredient into another when they are the same thing (e.g. 'pitted dates' into 'dates'). Rewrites every recipe file that uses it, moves aliases and the pantry entry, and records the alias in ingredients.yaml so future saves resolve to the target. Check pb_save_recipe's new_ingredients after a batch for candidates.",
   schema: {
-    from: z9.string().min(1),
-    into: z9.string().min(1)
+    from: z10.string().min(1),
+    into: z10.string().min(1)
   },
   handler: ({ from, into }, ctx) => text(mergeIngredients(ctx, from, into))
 });
@@ -381,7 +403,7 @@ var pb_open_ui_default = defineTool({
 });
 
 // src/mcp/tools/pb_pantry.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var pb_pantry_list = defineTool({
   name: "pb_pantry_list",
   description: "What's in the pantry: canonical ingredient names with optional quantity, unit and note.",
@@ -403,12 +425,12 @@ var pb_pantry_add = defineTool({
   name: "pb_pantry_add",
   description: "Add items to the pantry (or update their quantity). Names are matched to the ingredient catalog (aliases, plurals and regional names: 'eggs', 'baby marrow', 'spring onions'); unknown names become new ingredients.",
   schema: {
-    items: z10.array(
-      z10.object({
-        name: z10.string().min(1),
-        qty: z10.number().nullable().optional(),
-        unit: z10.string().nullable().optional(),
-        note: z10.string().nullable().optional()
+    items: z11.array(
+      z11.object({
+        name: z11.string().min(1),
+        qty: z11.number().nullable().optional(),
+        unit: z11.string().nullable().optional(),
+        note: z11.string().nullable().optional()
       })
     ).min(1)
   },
@@ -418,8 +440,8 @@ var pb_pantry_remove = defineTool({
   name: "pb_pantry_remove",
   description: "Remove items from the pantry by name, or everything with all:true.",
   schema: {
-    names: z10.array(z10.string()).optional(),
-    all: z10.boolean().optional()
+    names: z11.array(z11.string()).optional(),
+    all: z11.boolean().optional()
   },
   handler: ({ names, all }, ctx) => {
     if (all) return text({ cleared: ctx.store.pantryClear() });
@@ -428,19 +450,19 @@ var pb_pantry_remove = defineTool({
 });
 
 // src/mcp/tools/pb_pantry_match.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var pb_pantry_match_default = defineTool({
   name: "pb_pantry_match",
   description: "What can I cook? Ranks recipes by how much of their required ingredients the pantry covers (staples like salt, oil and 'from your kitchen' items, and optional items, never count against a recipe; printed alternatives and the parts of composite ingredients do count). Add `ingredients` for things you have right now; use_pantry:false to match only those. Returns coverage, what's missing, and near misses (1\u20132 items short).",
   schema: {
-    ingredients: z11.array(z11.string()).optional(),
-    use_pantry: z11.boolean().optional().describe("default true"),
-    min_coverage: z11.number().min(0).max(1).optional().describe("default 0.5"),
-    max_missing: z11.number().int().min(0).optional(),
-    limit: z11.number().int().min(1).max(50).optional().describe("default 10"),
-    tags: z11.partialRecord(z11.enum(ALL_CATEGORIES), z11.array(z11.string())).optional(),
-    exclude_allergens: z11.array(z11.string()).optional(),
-    max_total_min: z11.number().optional()
+    ingredients: z12.array(z12.string()).optional(),
+    use_pantry: z12.boolean().optional().describe("default true"),
+    min_coverage: z12.number().min(0).max(1).optional().describe("default 0.5"),
+    max_missing: z12.number().int().min(0).optional(),
+    limit: z12.number().int().min(1).max(50).optional().describe("default 10"),
+    tags: z12.partialRecord(z12.enum(ALL_CATEGORIES), z12.array(z12.string())).optional(),
+    exclude_allergens: z12.array(z12.string()).optional(),
+    max_total_min: z12.number().optional()
   },
   handler: ({ ingredients, use_pantry, min_coverage, max_missing, limit, ...filters }, ctx) => {
     const r = matchRecipes(ctx, {
@@ -466,13 +488,163 @@ var pb_pantry_match_default = defineTool({
   }
 });
 
+// src/mcp/tools/pb_plan.ts
+import { z as z13 } from "zod";
+var pb_plan_default = defineTool({
+  name: "pb_plan",
+  description: "The saved meal plan (shared with the web UI). get: the planned recipes and how much they share. set: replace the plan with `slugs`. add / remove: adjust it. clear: empty it. `servings` sets the portions wanted per recipe (quantities on the shopping list scale from the recipe's own servings).",
+  schema: {
+    action: z13.enum(["get", "set", "add", "remove", "clear"]),
+    slugs: z13.array(z13.string()).optional(),
+    servings: z13.record(z13.string(), z13.number().positive()).optional().describe("slug \u2192 portions wanted, e.g. {'harissa-chicken-traybake': 4}")
+  },
+  handler: ({ action, slugs, servings }, ctx) => {
+    const current = getPlan(ctx);
+    let items = current.items;
+    if (action === "clear") items = [];
+    else if (action === "set") items = (slugs ?? []).map((slug) => ({ slug }));
+    else if (action === "add") {
+      if (!slugs?.length) return errorResult("slugs required");
+      const have = new Set(items.map((i) => i.slug));
+      items = [...items, ...slugs.filter((s) => !have.has(s)).map((slug) => ({ slug }))];
+    } else if (action === "remove") {
+      if (!slugs?.length) return errorResult("slugs required");
+      const drop = new Set(slugs);
+      items = items.filter((i) => !drop.has(i.slug));
+    }
+    if (servings) {
+      items = items.map((i) => servings[i.slug] ? { ...i, servings: servings[i.slug] } : i);
+    }
+    const unknown = (slugs ?? []).filter((s) => !ctx.store.getRecipe(s));
+    const saved = action === "get" ? current : savePlan(ctx, { items, confirmed: current.confirmed });
+    const { plan } = suggestRecipes(ctx, { plan: saved.items.map((i) => i.slug), limit: 1 });
+    return text({
+      recipes: saved.items.map((i) => ({
+        slug: i.slug,
+        title: plan.recipes.find((r) => r.slug === i.slug)?.title,
+        servings: i.servings ?? void 0
+      })),
+      to_buy: plan.to_buy,
+      from_pantry: plan.from_pantry,
+      shared: plan.shared,
+      reuse: plan.reuse,
+      confirmed_pantry: saved.confirmed.length ? saved.confirmed : void 0,
+      unknown_slugs: unknown.length ? unknown : void 0
+    });
+  }
+});
+
+// src/mcp/tools/pb_plan_shopping_list.ts
+import { z as z14 } from "zod";
+var pb_plan_shopping_list_default = defineTool({
+  name: "pb_plan_shopping_list",
+  description: "Grocery list for the saved plan (or `slugs`): distinct items to buy with merged quantities, grouped by aisle, each with the recipes that use it. `pantry_check` lists the pantry items the plan relies on \u2014 ask the user to confirm those are really there before the list is final; pass the ones they confirm as `confirmed` and the ones they're out of as `out_of` (those leave the pantry and move onto the list). `needs_confirmation` is empty once everything is settled. Staples (salt, oil\u2026) are listed separately.",
+  schema: {
+    slugs: z14.array(z14.string()).optional().describe("defaults to the saved plan"),
+    servings: z14.record(z14.string(), z14.number().positive()).optional().describe("slug \u2192 portions wanted; scales quantities"),
+    confirmed: z14.array(z14.string()).optional().describe("pantry items the user confirmed"),
+    out_of: z14.array(z14.string()).optional().describe("pantry items the user is out of"),
+    format: z14.enum(["json", "text"]).optional().describe("default json; text is paste-ready")
+  },
+  handler: ({ slugs, servings, confirmed, out_of, format }, ctx) => {
+    const items = slugs?.map((slug) => ({ slug, servings: servings?.[slug] ?? null }));
+    const list = shoppingList(ctx, { items, confirmed, out_of });
+    if (format === "text") return text(renderShoppingList(list));
+    return text({
+      recipes: list.recipes.map((r) => ({
+        title: r.title,
+        servings: r.servings ?? void 0,
+        scaled: r.scale !== 1 ? `\xD7${Math.round(r.scale * 100) / 100}` : void 0
+      })),
+      buy: list.buy.map((l) => ({
+        item: l.canonical,
+        amount: l.amount ?? void 0,
+        aisle: l.aisle,
+        for: l.for
+      })),
+      pantry_check: list.pantry_check.map((c) => ({
+        item: c.canonical,
+        amount: c.amount ?? void 0,
+        in_pantry: c.in_pantry ?? void 0,
+        for: c.for,
+        confirmed: c.confirmed
+      })),
+      needs_confirmation: list.needs_confirmation.length ? list.needs_confirmation : void 0,
+      optional: list.optional.length ? list.optional.map((l) => l.canonical) : void 0,
+      staples: list.staples,
+      summary: {
+        to_buy: list.summary.to_buy,
+        from_pantry: list.summary.from_pantry,
+        shared: list.summary.shared,
+        reuse: list.summary.reuse
+      },
+      removed_from_pantry: list.removed_from_pantry.length ? list.removed_from_pantry : void 0,
+      unknown_slugs: list.unknown_slugs.length ? list.unknown_slugs : void 0
+    });
+  }
+});
+
+// src/mcp/tools/pb_plan_suggest.ts
+import { z as z15 } from "zod";
+var pb_plan_suggest_default = defineTool({
+  name: "pb_plan_suggest",
+  description: "Meal planning around shared ingredients. Given a seed recipe and/or the current plan, ranks recipes by how much of their shopping is already covered \u2014 `shares` (already on the list for another planned recipe), `from_pantry`, and `new` (what they would add). `reuse` is the covered share (0\u20131), weighted so fresh items count more than dry goods. Repeating a planned dish is penalised unless variety:false. With `auto: n` it instead fills the plan with n more recipes that minimise the whole list (beam search) and returns the resulting slugs \u2014 save them with pb_plan. Nothing is saved by this tool.",
+  schema: {
+    seed: z15.string().optional().describe("recipe slug to plan around"),
+    plan: z15.array(z15.string()).optional().describe("slugs already planned; defaults to the saved plan"),
+    auto: z15.number().int().min(1).max(14).optional().describe("fill the plan with this many more"),
+    limit: z15.number().int().min(1).max(50).optional().describe("default 8"),
+    variety: z15.boolean().optional().describe("default true"),
+    use_pantry: z15.boolean().optional().describe("default true"),
+    tags: z15.partialRecord(z15.enum(ALL_CATEGORIES), z15.array(z15.string())).optional(),
+    exclude_allergens: z15.array(z15.string()).optional(),
+    exclude_ingredients: z15.array(z15.string()).optional(),
+    max_total_min: z15.number().optional()
+  },
+  handler: ({ seed, plan, auto, limit, variety, use_pantry, ...filters }, ctx) => {
+    if (auto) {
+      const r2 = autofillPlan(ctx, { seed, plan, count: auto, variety, use_pantry, filters });
+      return text({
+        plan_slugs: r2.slugs,
+        added: r2.added.map((s) => ({
+          slug: s.slug,
+          title: s.title,
+          reuse: s.reuse,
+          shares: s.shares,
+          from_pantry: s.from_pantry,
+          new: s.new,
+          repeats: s.repeats
+        })),
+        summary: r2.plan,
+        unknown_slugs: r2.unknown_slugs.length ? r2.unknown_slugs : void 0,
+        next: "Show the user the plan; when they agree, pb_plan {action:'set', slugs: plan_slugs}."
+      });
+    }
+    const r = suggestRecipes(ctx, { seed, plan, limit: limit ?? 8, variety, use_pantry, filters });
+    return text({
+      plan: r.plan,
+      suggestions: r.suggestions.map((s) => ({
+        slug: s.slug,
+        title: s.title,
+        total_min: s.total_min ?? void 0,
+        reuse: s.reuse,
+        shares: s.shares,
+        from_pantry: s.from_pantry,
+        new: s.new,
+        repeats: s.repeats
+      })),
+      unknown_slugs: r.unknown_slugs.length ? r.unknown_slugs : void 0
+    });
+  }
+});
+
 // src/mcp/tools/pb_providers.ts
-import { z as z12 } from "zod";
+import { z as z16 } from "zod";
 var pb_providers_default = defineTool({
   name: "pb_providers",
   description: "Meal-box provider profiles. Without `id`: list them (id, name, how to recognise a card). With `id`: the extraction guide for that provider's cards plus the tag vocabulary \u2014 read it once before extracting a batch of cards.",
   schema: {
-    id: z12.string().optional().describe('e.g. "ucook"; "generic" for anything else')
+    id: z16.string().optional().describe('e.g. "ucook"; "generic" for anything else')
   },
   handler: ({ id }, ctx) => {
     if (!id) {
@@ -500,6 +672,7 @@ var pb_providers_default = defineTool({
         `- Brands stripped from canonical names: ${p.brands.join(", ") || "none"}`,
         `- Kitchen items treated as equipment: ${Object.keys(p.equipment_terms).join(", ") || "none"}`,
         `- Nutrition basis default: ${p.nutrition_basis}; default servings: ${p.default_servings ?? "none"}`,
+        `- Upright card shape: ${p.orientation ?? "varies"} (photos that don't match are flagged with rotation_hint; fix them with pb_inbox_rotate)`,
         "",
         "## Tag vocabulary (closed = only these values; open = top values, new ones allowed)",
         ...Object.entries(summary).map(
@@ -511,13 +684,13 @@ var pb_providers_default = defineTool({
 });
 
 // src/mcp/tools/pb_rebuild.ts
-import { z as z13 } from "zod";
+import { z as z17 } from "zod";
 var pb_rebuild_default = defineTool({
   name: "pb_rebuild",
   description: "Re-sync the index from pantrybase/recipes/*.md (markdown is the source of truth), reloading ingredients.yaml, vocabulary.yaml and provider profiles. Default is incremental (mtime/hash); full:true re-parses every file (use after editing the vocabulary or catalog); reembed:true also recomputes all embeddings.",
   schema: {
-    full: z13.boolean().optional(),
-    reembed: z13.boolean().optional()
+    full: z17.boolean().optional(),
+    reembed: z17.boolean().optional()
   },
   handler: ({ full, reembed }, ctx) => {
     const reloaded = ctx.refresh(true);
@@ -527,7 +700,7 @@ var pb_rebuild_default = defineTool({
 });
 
 // src/mcp/tools/pb_save_recipe.ts
-import { z as z14 } from "zod";
+import { z as z18 } from "zod";
 
 // src/files/slug.ts
 var MAX_SLUG = 60;
@@ -628,10 +801,10 @@ var pb_save_recipe_default = defineTool({
   description: "Save a recipe (new or, with `slug`, an update). Writes pantrybase/recipes/<slug>.md as the source of truth and indexes it. For meal-box cards read pb_providers {id} first and follow its guide; set provider.id so its rules apply. Pass `ingest` with every inbox photo of the card ({id, side}) \u2014 they are archived to images/<slug>/ and marked done; re-sending already-attached photos is a safe no-op. Ingredients need `raw` (as printed) and `canonical` (generic singular name, no brand) plus source box|kitchen. Steps are objects {title, text, techniques, uses, equipment, temp_c, minutes} (plain strings are accepted). Tags by category (protein, diet, starch, flavor, texture, cuisine, dish, meal, method, time, season, other) are normalised against the vocabulary. Write a `blurb` in your own words for semantic search and record unreadable fields in extraction.uncertain. Returns {saved, slug, \u2026} or {saved:false, duplicate_of:[\u2026]} \u2014 if it is a different recipe pass allow_duplicate:true; if it is the same card, attach the photos to that slug or skip them.",
   schema: {
     ...recipeInputSchema.shape,
-    ingest: z14.array(z14.object({ id: z14.number().int(), side: z14.enum(IMAGE_SIDES) })).optional().describe(
+    ingest: z18.array(z18.object({ id: z18.number().int(), side: z18.enum(IMAGE_SIDES) })).optional().describe(
       "Inbox photos of this card, e.g. [{id: 12, side: 'front'}, {id: 13, side: 'back'}]"
     ),
-    allow_duplicate: z14.boolean().optional()
+    allow_duplicate: z18.boolean().optional()
   },
   handler: ({ allow_duplicate, ingest, ...input }, ctx) => {
     return text(saveRecipe(ctx, input, { allow_duplicate, ingest }));
@@ -639,22 +812,22 @@ var pb_save_recipe_default = defineTool({
 });
 
 // src/mcp/tools/pb_search.ts
-import { z as z15 } from "zod";
+import { z as z19 } from "zod";
 var pb_search_default = defineTool({
   name: "pb_search",
   description: "Search recipes: hybrid keyword + semantic ranking (RRF) over title, blurb, ingredients and method, with filters. Omit `query` to just filter/browse. Tag filters accept any category \u2014 assigned tags (cuisine, diet, dish, protein, flavor\u2026) and derived facets (allergen, equipment, technique, chef, provider, plan); parents expand (cuisine:asian matches thai). Returns compact summaries; use pb_get_recipe for details.",
   schema: {
-    query: z15.string().optional().describe("Free text: dish, ingredient, technique, mood, occasion\u2026"),
-    limit: z15.number().int().min(1).max(100).optional().describe("default 10"),
-    tags: z15.partialRecord(z15.enum(ALL_CATEGORIES), z15.array(z15.string())).optional().describe("e.g. {cuisine:['thai'], diet:['vegetarian']} \u2014 OR within a category, AND across"),
-    exclude_allergens: z15.array(z15.string()).optional().describe('e.g. ["dairy", "tree-nuts"]'),
-    exclude_ingredients: z15.array(z15.string()).optional(),
-    max_total_min: z15.number().optional(),
-    max_active_min: z15.number().optional().describe("Hands-on minutes"),
-    provider: z15.string().optional(),
-    source_kind: z15.enum(SOURCE_KINDS).optional(),
-    needs_review: z15.boolean().optional().describe("true = only recipes flagged for review"),
-    mode: z15.enum(["hybrid", "lexical", "semantic"]).optional()
+    query: z19.string().optional().describe("Free text: dish, ingredient, technique, mood, occasion\u2026"),
+    limit: z19.number().int().min(1).max(100).optional().describe("default 10"),
+    tags: z19.partialRecord(z19.enum(ALL_CATEGORIES), z19.array(z19.string())).optional().describe("e.g. {cuisine:['thai'], diet:['vegetarian']} \u2014 OR within a category, AND across"),
+    exclude_allergens: z19.array(z19.string()).optional().describe('e.g. ["dairy", "tree-nuts"]'),
+    exclude_ingredients: z19.array(z19.string()).optional(),
+    max_total_min: z19.number().optional(),
+    max_active_min: z19.number().optional().describe("Hands-on minutes"),
+    provider: z19.string().optional(),
+    source_kind: z19.enum(SOURCE_KINDS).optional(),
+    needs_review: z19.boolean().optional().describe("true = only recipes flagged for review"),
+    mode: z19.enum(["hybrid", "lexical", "semantic"]).optional()
   },
   handler: async ({ query, limit, mode, ...filters }, ctx) => {
     const res = await searchRecipes(ctx, { query, limit, mode, filters });
@@ -695,7 +868,7 @@ var pb_stats_default = defineTool({
 });
 
 // src/mcp/tools/pb_synthesis_context.ts
-import { z as z16 } from "zod";
+import { z as z20 } from "zod";
 
 // src/synthesis/context.ts
 var STEP_CHARS = 220;
@@ -829,14 +1002,14 @@ var pb_synthesis_context_default = defineTool({
   name: "pb_synthesis_context",
   description: "Material for inventing a new recipe from the collection: a few relevant source recipes in compact form, the ingredients, pairings, techniques, cuisines and flavours they share, and (with use_pantry) what the pantry covers and what is commonly missing. Pick sources by `query`, explicit `slugs`, pantry fit, or tag filters. Then write the recipe and save it with pb_save_recipe (source.kind 'synthesized', derived_from the slugs you drew on).",
   schema: {
-    query: z16.string().optional().describe('What to make, e.g. "quick spicy noodle dinner"'),
-    slugs: z16.array(z16.string()).optional(),
-    use_pantry: z16.boolean().optional(),
-    ingredients: z16.array(z16.string()).optional().describe("Extra things available right now"),
-    tags: z16.partialRecord(z16.enum(ALL_CATEGORIES), z16.array(z16.string())).optional(),
-    exclude_allergens: z16.array(z16.string()).optional(),
-    max_total_min: z16.number().optional(),
-    n: z16.number().int().min(1).max(12).optional().describe("Number of source recipes (default 5)")
+    query: z20.string().optional().describe('What to make, e.g. "quick spicy noodle dinner"'),
+    slugs: z20.array(z20.string()).optional(),
+    use_pantry: z20.boolean().optional(),
+    ingredients: z20.array(z20.string()).optional().describe("Extra things available right now"),
+    tags: z20.partialRecord(z20.enum(ALL_CATEGORIES), z20.array(z20.string())).optional(),
+    exclude_allergens: z20.array(z20.string()).optional(),
+    max_total_min: z20.number().optional(),
+    n: z20.number().int().min(1).max(12).optional().describe("Number of source recipes (default 5)")
   },
   handler: async ({ query, slugs, use_pantry, ingredients, n, ...filters }, ctx) => text(await synthesisContext(ctx, { query, slugs, use_pantry, ingredients, n, filters }))
 });
@@ -853,11 +1026,16 @@ var tools = [
   pb_pantry_list,
   pb_pantry_add,
   pb_pantry_remove,
+  // meal planning
+  pb_plan_suggest_default,
+  pb_plan_default,
+  pb_plan_shopping_list_default,
   // capture
   pb_providers_default,
   pb_ingest_source_default,
   pb_inbox_next_default,
   pb_inbox_image_default,
+  pb_inbox_rotate_default,
   pb_inbox_resolve_default,
   pb_inbox_list_default,
   pb_save_recipe_default,