fix(block): rank unlocked recipes before horizon choices

Author: ApocDev

app/e2e/README.md

@@ -106,6 +106,8 @@ Mutating (`mut/`, against the isolated server):
 - **`module-presets.e2e.ts`** — module templates (#99): save a row's loadout as
   a preset from the modules dialog, star it as the default template, and a
   compatible new recipe row starts with that loadout baked in.
+- **`recipe-order.e2e.ts`** — recipe selection keeps the best currently unlocked
+  recipe above cheaper choices that are only available in the future horizon.
 
 ## CI
 

app/e2e/mut/recipe-order.e2e.ts

@@ -0,0 +1,21 @@
+import { expect, test } from "@playwright/test";
+import { addGoal, createBlock, setPlanningHorizon } from "./helpers";
+
+test("recipe picker ranks unlocked recipes before cheaper future tiers", async ({ page }) => {
+  await createBlock(page);
+  await addGoal(page, "seaweed", "Seaweed");
+  await setPlanningHorizon(page, "Future");
+
+  await page.locator('button[aria-label^="add a recipe that makes "]').click();
+  const picker = page.getByRole("dialog", { name: "Recipes that make Seaweed" });
+  const candidates = picker.locator("[data-recipe-candidate]");
+
+  await expect(picker.getByText("Unlocked now", { exact: true })).toBeVisible();
+  await expect(candidates.first()).toHaveAttribute("data-recipe-candidate", "seaweed-1");
+  await expect(
+    picker.locator('[data-recipe-candidate="seaweed-1"]'),
+  ).toContainText("unlocked now");
+  await expect(
+    picker.locator('[data-recipe-candidate="seaweed-3"]'),
+  ).toContainText("available in horizon");
+});

app/src/components/block/recipe-picker-dialog.tsx

@@ -9,8 +9,8 @@ import { fmtCost } from "./format.ts";
 
 type Candidate = Awaited<ReturnType<typeof recipeCandidatesFn>>[number];
 
-/** Recipe picker — the candidates that make/consume a good, availability-sorted,
- * with io at a glance and TURD/tech lock state. Floats over everything. */
+/** Recipe picker — current unlocks first, then horizon choices and locked rows,
+ * with cost ordering inside each group. Floats over everything. */
 export function RecipePickerDialog({
   mode,
   goodDisplay,
@@ -46,7 +46,15 @@ export function RecipePickerDialog({
               const isAdded = added.includes(r.name);
               const locked = !r.selectable && !r.superseded;
               const previous = candidates[index - 1];
-              const beginsGroup = !previous || previous.selectable !== r.selectable;
+              const group = r.unlockedNow ? "now" : r.selectable ? "horizon" : "locked";
+              const previousGroup = previous
+                ? previous.unlockedNow
+                  ? "now"
+                  : previous.selectable
+                    ? "horizon"
+                    : "locked"
+                : null;
+              const beginsGroup = group !== previousGroup;
               const machines = r.machineAvailability.options;
               const availableMachine =
                 machines.find((machine) => machine.availableNow) ?? machines[0];
@@ -55,13 +63,15 @@ export function RecipePickerDialog({
                 <div key={r.name}>
                   {beginsGroup && (
                     <div
-                      className={`px-3 pt-3 pb-1 text-sm font-semibold uppercase ${r.selectable ? "text-success" : "text-destructive"}`}
+                      className={`px-3 pt-3 pb-1 text-sm font-semibold uppercase ${group === "locked" ? "text-destructive" : "text-success"}`}
                     >
-                      {r.selectable
-                        ? r.horizonMode === "now"
-                          ? "Unlocked now"
-                          : "Available in planning horizon"
-                        : "Locked or unavailable"}
+                      {group === "now"
+                        ? "Unlocked now"
+                        : group === "horizon"
+                          ? r.horizonMode === "now"
+                            ? "Available with current science"
+                            : "Available in planning horizon"
+                          : "Locked or unavailable"}
                     </div>
                   )}
                   <button
@@ -86,7 +96,7 @@ export function RecipePickerDialog({
                         <span className="text-base">{r.display ?? r.name}</span>
                         <span className="ml-auto flex shrink-0 items-center gap-2">
                           {r.cost != null && (
-                            <Tooltip content="estimated cost per craft (cost analysis) — sorted cheapest first">
+                            <Tooltip content="estimated cost per craft (cost analysis) — sorted cheapest first within each availability group">
                               <span className="text-sm text-muted-foreground">
                                 ¥{fmtCost(r.cost)}
                               </span>
@@ -170,7 +180,11 @@ export function RecipePickerDialog({
                       {r.selectable && (
                         <span className="flex items-center gap-1 text-sm text-success">
                           <Check className="size-3.5 shrink-0" />
-                          {r.horizonMode === "now" ? "unlocked now" : "available in horizon"}
+                          {r.unlockedNow
+                            ? "unlocked now"
+                            : r.horizonMode === "now"
+                              ? "available with current science"
+                              : "available in horizon"}
                           {availableMachine &&
                             ` · ${availableMachine.display ?? availableMachine.name}`}
                         </span>

app/src/db/queries.server.ts

@@ -523,10 +523,25 @@ export function unlockedItems(names: string[]): Set<string> {
 type MachineOption = ReturnType<typeof machinesForRecipe>[number] & {
   startEnabled: boolean;
   unlockedBy: { tech: string; display: string | null }[];
+  unlockedNow: boolean;
   availableNow: boolean;
   favorite: boolean;
 };
 
+/** Whether the recipe exists in the synced save right now, independent of the
+ * broader planning horizon. TURD recipes count only when their branch is the
+ * selected one; stale researched-tech data must not resurrect another branch. */
+function isRecipeUnlockedNow(
+  enabled: boolean,
+  unlocks: RecipeLockState,
+  researched: ReadonlySet<string>,
+): boolean {
+  return (
+    enabled ||
+    unlocks.some((unlock) => (unlock.isTurdSub ? unlock.turdSelected : researched.has(unlock.tech)))
+  );
+}
+
 /** Request-scoped machine enrichment for several recipe candidates. */
 export function machineOptionsForRecipes(recipeNames: string[]): Map<string, MachineOption[]> {
   const uniq = [...new Set(recipeNames)].filter((name) => name);
@@ -549,6 +564,7 @@ export function machineOptionsForRecipes(recipeNames: string[]): Map<string, Mac
     craftRows.map((recipe) => recipe.name),
     new Set(selections.values()),
   );
+  const researched = syncedResearchedTechs();
   const availability = computeAvailByRecipe(
     craftRows,
     locksByRecipe,
@@ -585,6 +601,9 @@ export function machineOptionsForRecipes(recipeNames: string[]): Map<string, Mac
           ...machine,
           startEnabled: crafts.some((recipe) => recipe.enabled),
           unlockedBy,
+          unlockedNow: crafts.some((recipe) =>
+            isRecipeUnlockedNow(recipe.enabled, locksByRecipe.get(recipe.name) ?? [], researched),
+          ),
           availableNow: crafts.some((recipe) => availability.get(recipe.name)?.availableNow),
           favorite: machine.name === favorite,
         };
@@ -4527,10 +4546,11 @@ export function allBlockRecipes(): string[] {
   ];
 }
 
-/** Recipe-picker candidates (producing/consuming X) with lock + TURD state,
- * sorted into usable and locked groups, cheapest first within each group. A
- * candidate is usable only when both its recipe and at least one compatible
- * building are available under the selected planning horizon. */
+/** Recipe-picker candidates (producing/consuming X) with lock + TURD state.
+ * Recipes and buildings unlocked in the synced save rank first, followed by
+ * other horizon-usable choices and then locked choices; cost breaks ties inside
+ * each group. A candidate is usable only when both its recipe and at least one
+ * compatible building are available under the selected planning horizon. */
 export function recipeCandidatesBatch(names: string[], mode: "produce" | "consume") {
   const uniq = [...new Set(names)].filter((name) => name);
   if (!uniq.length) return new Map<string, never[]>();
@@ -4550,6 +4570,7 @@ export function recipeCandidatesBatch(names: string[], mode: "produce" | "consum
   const recipesByNameMap = recipesByName(recipeNames);
   const selections = getTurdSelections();
   const locksByRecipe = recipeLockStatesByRecipe(recipeNames, new Set(selections.values()));
+  const researched = syncedResearchedTechs();
   const horizon = getResearchHorizon();
   const availability = computeAvailByRecipe(allBase, locksByRecipe, horizon, selections);
   const machineOptions = machineOptionsForRecipes(recipeNames);
@@ -4586,9 +4607,13 @@ export function recipeCandidatesBatch(names: string[], mode: "produce" | "consum
             : avail.availableNow;
       const superseded = supersededMap.get(r.name) ?? null;
       const selectable = recipeAvailable && machineAvailable && !superseded;
-      // Cost orders the usable and locked groups independently. Superseded
-      // recipes remain last because the selected TURD removed them in-game.
-      const rank = selectable ? 0 : superseded ? 2 : 1;
+      const recipeUnlockedNow = isRecipeUnlockedNow(r.enabled, unlocks, researched);
+      const machineUnlockedNow =
+        machines.length === 0 || machines.some((machine) => machine.unlockedNow);
+      const unlockedNow = selectable && recipeUnlockedNow && machineUnlockedNow;
+      // Cost orders each availability group independently. Superseded recipes
+      // remain last because the selected TURD removed them in-game.
+      const rank = unlockedNow ? 0 : selectable ? 1 : superseded ? 3 : 2;
       // io summary so lookalike recipes (Py loves reusing names) tell apart at a glance
       const full = recipesByNameMap.get(r.name);
       return {
@@ -4598,12 +4623,14 @@ export function recipeCandidatesBatch(names: string[], mode: "produce" | "consum
         available,
         avail,
         selectable,
+        unlockedNow,
         horizonMode: horizon.mode,
         machineAvailability: {
           available: machineAvailable,
           options: machines.map((machine) => ({
             name: machine.name,
             display: machine.display,
+            unlockedNow: machine.unlockedNow,
             availableNow: machine.availableNow,
             startEnabled: machine.startEnabled,
             unlockedBy: machine.unlockedBy,

app/src/db/queries.test.ts

@@ -609,6 +609,23 @@ describe("recipeCandidates availability: prerequisite-gated techs (empty own cos
     const exotic = recipeCandidates("circuit", "produce").find((c) => c.name === "circuit-exotic")!;
     expect(exotic.avail.research).toBe("available");
   });
+
+  it("sorts a currently unlocked recipe before a cheaper horizon-only recipe", () => {
+    seed();
+    db.run(sql`
+      INSERT INTO cost_analysis (scope, name, kind, cost) VALUES
+        ('recipe','circuit-basic','recipe',10),
+        ('recipe','circuit-exotic','recipe',1)
+    `);
+    setResearchHorizon({ mode: "future", researched: ["t-basic"] });
+
+    const candidates = recipeCandidates("circuit", "produce");
+    expect(candidates.map((candidate) => candidate.name)).toEqual([
+      "circuit-basic",
+      "circuit-exotic",
+    ]);
+    expect(candidates.map((candidate) => candidate.unlockedNow)).toEqual([true, false]);
+  });
 });
 
 describe("recipeCandidates combined recipe and building availability", () => {
@@ -697,6 +714,19 @@ describe("recipeCandidates combined recipe and building availability", () => {
     ]);
     expect(candidates.every((candidate) => candidate.selectable)).toBe(true);
   });
+
+  it("sorts a recipe with a current building before a cheaper horizon-only building", () => {
+    seedGenerators();
+    setResearchHorizon({ mode: "future", packs: [], researched: [] });
+
+    const candidates = recipeCandidates("power", "produce");
+    expect(candidates.map((candidate) => candidate.name)).toEqual([
+      "generate-steam",
+      "generate-wind",
+    ]);
+    expect(candidates.map((candidate) => candidate.unlockedNow)).toEqual([true, false]);
+    expect(candidates.every((candidate) => candidate.selectable)).toBe(true);
+  });
 });
 
 describe("batched recipe reads", () => {

app/src/server/agent-tools.server.ts

@@ -262,6 +262,7 @@ function optionsFor(
           fastest && resolved && fastest.craftingSpeed > resolved.craftingSpeed
             ? describe(fastest)
             : undefined,
+        unlockedNow: r.unlockedNow, // recipe + at least one building exist in the synced save
         // availability vs the user's planning horizon (now vs future)
         availableNow: r.avail.availableNow, // research reached, turd not blocked (pickable counts)
         buildableNow: r.avail.buildableNow, // stricter: turd ACTIVE — no unmade pick (NOW planning)
@@ -286,7 +287,7 @@ function optionsFor(
 
 export const recipeOptions = tool({
   description:
-    "List the recipes that PRODUCE (or CONSUME) a good, ranked the way the picker ranks them: recipes whose research and building are available under the planning horizon first, then locked choices, cheapest by cost analysis within each group. Each candidate already includes its inputs (in), outputs (out), lock state, cost, and unlocking tech — so you rarely need recipeInfo afterward. Cost is an LP shadow price — a HINT for tie-breaking, NOT the deciding factor: the right recipe is usually about the correct production TIER and chain, not the cheapest. `machine` names the building a draft would ACTUALLY solve with — the user's stored favorite for this recipe's category, else the same safe low-tier fallback `computeBlock` defaults to (never necessarily the fastest); its availability note (\"needs <tech>\") describes THIS machine, since that's what really gates buildability. `fastestMachine` is included only when a strictly faster tier exists beyond that pick, so you can still see whether upgrading the favorite is worth it. To resolve SEVERAL goods at once, prefer recipeOptionsBatch.",
+    "List the recipes that PRODUCE (or CONSUME) a good, ranked the way the picker ranks them: choices whose recipe and building are unlocked in the synced save first, then other planning-horizon choices, then locked choices; cheapest by cost analysis within each group. `unlockedNow` identifies that first group. Each candidate already includes its inputs (in), outputs (out), lock state, cost, and unlocking tech — so you rarely need recipeInfo afterward. Cost is an LP shadow price — a HINT for tie-breaking, NOT the deciding factor: the right recipe is usually about the correct production TIER and chain, not the cheapest. `machine` names the building a draft would ACTUALLY solve with — the user's stored favorite for this recipe's category, else the same safe low-tier fallback `computeBlock` defaults to (never necessarily the fastest); its availability note (\"needs <tech>\") describes THIS machine, since that's what really gates buildability. `fastestMachine` is included only when a strictly faster tier exists beyond that pick, so you can still see whether upgrading the favorite is worth it. To resolve SEVERAL goods at once, prefer recipeOptionsBatch.",
   inputSchema: z.object({
     good: z.string().describe("Internal good name (from searchGoods), e.g. 'molten-iron'"),
     direction: z

docs/guide/blocks.md

@@ -50,11 +50,13 @@ instead opens **Recipes that consume _goal_**. Within a recipe row:
 - Hover recipe, technology, and item details when you need the precise inputs, outputs, or
   unlock status.
 
-The picker groups choices available under the current planning horizon first and sorts each
-group by ascending estimated cost. A recipe is available only when both its own research and
-at least one compatible building are available. Locked rows are disabled and name the missing
-recipe research or building research; recipes replaced by a TURD upgrade remain visible with
-their explanation. PyOps never adds a full chain without your choice.
+The picker puts choices already unlocked in the synced save first, then recipes available
+later in the current planning horizon, and finally locked choices. It sorts each group by
+ascending estimated cost, so the first row is normally the cheapest recipe you can build
+right now. A recipe is available only when both its own research and at least one compatible
+building are available. Locked rows are disabled and name the missing recipe research or
+building research; recipes replaced by a TURD upgrade remain visible with their explanation.
+PyOps never adds a full chain without your choice.
 
 ## Choose machines, fuels, and modules