feat(agent): multi-goal + keep-in-stock goals, and module-fill the building bill

Let the assistant propose a block with multiple output goals, each
optionally a keep-in-stock goal (#38): a goal carries `stock` (amount to
keep on hand) and `window` (refill seconds, default 600), and the solver
rate is derived as stock/window. This gives building/mall-supply blocks a
sane primitive — "keep 80 vrauks-paddock on hand" seeded from the building
bill — instead of a fabricated per-second rate the model kept balking at
and deferring. goals[0] still anchors naming/sizing; the legacy
target+rate shorthand is unchanged. The draft return carries the full
goals array so the chat apply path (single block and plan) persists stock
goals into BlockData instead of flattening them to {name, rate}.

Also fix buildingBill's machine counts: it did a bare computeBlock with no
module pass, so for Py's near-useless-unmoduled creature/farm buildings it
over-counted ~10-15x and disagreed with submitBlock's own module-filled
counts. Extract the two-pass module-fill solve into a shared
solveWithModuleFill used by both; a test now asserts they agree.

Prompt: mall/supply blocks use keep-in-stock goals seeded from the bill,
the recursion into the machines' own intermediates (circuits, small parts)
is the deliverable rather than a stop signal, and "No deferring" now names
the machine/fuel/sink-block case explicitly.

Author: ApocDev

app/src/routes/assistant.tsx

@@ -37,7 +37,8 @@ import { ShowInGameButton } from "#/components/assistant/show-in-game-button.tsx
 import { HelpButton } from "#/components/help-drawer.tsx";
 import { SidebarShell } from "#/components/sidebar-shell.tsx";
 import { ItemHover, RecipeHover, TechHover } from "#/lib/recipe-card";
-import { formatRate } from "#/lib/format";
+import { formatQty, formatRate } from "#/lib/format";
+import { STOCK_WINDOW_DEFAULT } from "#/lib/goals";
 import { toast } from "#/lib/toast-store";
 import {
   aiConfigFn,
@@ -1353,11 +1354,17 @@ function Prose({ text }: { text: string }) {
 /* ── Block draft preview ──────────────────────────────────────────────────── */
 
 type GoodRate = { good: string; rate?: number | null };
+// One output goal (#38): either a throughput `rate` or a keep-in-stock `stock`
+// (+ refill `window`, seconds) — the shape persisted into BlockData.goals.
+type DraftGoal = { name: string; rate: number; stock?: number; window?: number };
 type Draft = {
   name?: string;
   target: string;
   targetDisplay?: string;
   rate: number;
+  // Full goal set from the draft (#38) — goals[0] is always target/rate, kept
+  // in sync for back-compat with older cached drafts that predate this field.
+  goals?: DraftGoal[];
   recipes: string[];
   modules?: Record<string, string[]>;
   machines?: Record<string, string>;
@@ -1419,6 +1426,14 @@ type PlanDraftData = {
 
 const fmtRate = (r?: number | null) => (r != null ? formatRate(r) : "");
 
+/** The goals to persist for a drafted block (#38): the draft's full `goals`
+ * array when present, else the legacy single target/rate synthesized into one
+ * — covers a stale cached draft from before this field existed. */
+function draftGoals(draft: Draft): DraftGoal[] {
+  if (draft.goals?.length) return draft.goals;
+  return [{ name: draft.target, rate: draft.rate }];
+}
+
 function refRow(label: ReactNode, items: string[] | undefined, prefer?: "recipe", warn?: boolean) {
   return items && items.length ? (
     <div className="mt-2.5">
@@ -1457,6 +1472,32 @@ function rateRow(label: ReactNode, entries: GoodRate[] | undefined) {
   ) : null;
 }
 
+const fmtWindow = (s: number) => (s >= 3600 ? `${s / 3600}h` : `${s / 60}m`);
+
+/** Every output goal (#38), shown only when a block has more than one — the
+ * common single-target case keeps its existing header-only display. A stock
+ * goal reads as "keep N (refill Xm)" instead of a rate. */
+function goalsRow(goals: DraftGoal[] | undefined) {
+  if (!goals || goals.length < 2) return null;
+  return (
+    <div className="mt-2.5">
+      <div className="text-xs uppercase tracking-wide text-muted-foreground">output goals</div>
+      <div className="mt-1 flex flex-wrap items-center gap-x-2 gap-y-1.5">
+        {goals.map((g) => (
+          <span key={g.name} className="inline-flex items-center gap-1">
+            <Ref name={g.name} />
+            <span className="text-xs text-muted-foreground">
+              {g.stock != null
+                ? `keep ${formatQty(g.stock)} (refill ${fmtWindow(g.window ?? STOCK_WINDOW_DEFAULT)})`
+                : fmtRate(g.rate)}
+            </span>
+          </span>
+        ))}
+      </div>
+    </div>
+  );
+}
+
 /** The shared body of a block draft / update card: recipes, imports, sub-blocks,
  * byproducts, TURD, invalid recipes — everything below the header + action button. */
 function DraftRows({ draft }: { draft: Draft }) {
@@ -1466,6 +1507,7 @@ function DraftRows({ draft }: { draft: Draft }) {
   }));
   return (
     <>
+      {goalsRow(draft.goals)}
       {refRow(`${draft.recipes.length} recipes`, draft.recipes, "recipe")}
       {rateRow("imports (external)", externalImports)}
       {draft.importsFromBlocks && draft.importsFromBlocks.length > 0 && (
@@ -1584,7 +1626,7 @@ function BlockDraft({
         data: {
           name: `${draft.targetDisplay ?? draft.target} (drafted)`,
           data: {
-            goals: [{ name: draft.target, rate: draft.rate }],
+            goals: draftGoals(draft),
             recipes: draft.recipes,
             ...(draft.modules && Object.keys(draft.modules).length
               ? { modules: draft.modules }
@@ -1814,7 +1856,7 @@ function PlanDraft({
         const res = await saveBlockFn({
           data: {
             name: draft.name ?? `${draft.targetDisplay ?? draft.target} (drafted)`,
-            data: { goals: [{ name: draft.target, rate: draft.rate }], recipes: draft.recipes },
+            data: { goals: draftGoals(draft), recipes: draft.recipes },
           },
         });
         made.push(res);
@@ -1954,6 +1996,7 @@ function PlanBlockPreview({
   return (
     <div className="mt-2 space-y-2 text-sm">
       {draft.notes && <p className="text-muted-foreground">{draft.notes}</p>}
+      {goalsRow(draft.goals)}
       <div>
         <div className="text-xs uppercase tracking-wide text-muted-foreground">recipes</div>
         <div className="mt-1 flex flex-wrap gap-1.5">

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

@@ -20,6 +20,7 @@ import { buildingBill, submitBlock } from "./agent-tools.server.ts";
 type Draft = {
   ok: boolean;
   buildings: { recipe: string; machine: string; count: number }[];
+  modules?: Record<string, string[]>;
 };
 
 type Bill = {
@@ -118,3 +119,78 @@ describe("solved building counts (draft buildings + buildingBill)", () => {
     expect(res.machines[0].count).toBe(13); // ceil(12.8) from the iron-plate block alone
   });
 });
+
+/**
+ * buildingBill used to skip the two-pass module-fill solve submitBlock already
+ * did (via a bare `computeBlock({goals, recipes})`), so for a moduled machine
+ * it reported a much bigger, UNMODULED count that disagreed with submitBlock's
+ * own draft for the exact same recipe/rate — the root cause behind the AI
+ * assistant reporting nonsensical "3520 vrauk paddocks" for Py's near-useless-
+ * unmoduled creature/farm buildings. Both tools now share `solveWithModuleFill`.
+ *
+ * Fixture: stone-furnace with 2 module slots and one +20%-speed module
+ * (unlocked via its own start-enabled crafting recipe) — no efficiency module,
+ * so the auto-fill algorithm's only lever is speed, which shaves the whole
+ * building count deterministically (see module-fill.test.ts).
+ */
+describe("buildingBill agrees with submitBlock's module-filled machine counts", () => {
+  let fx: TestDb;
+
+  beforeEach(async () => {
+    fx = await makeTestDb();
+    fx.db.exec(`
+      INSERT INTO items (name, display) VALUES
+        ('iron-ore','Iron ore'),('iron-plate','Iron plate'),
+        ('stone','Stone'),('stone-furnace','Stone furnace'),
+        ('speed-module-1','Speed module');
+
+      INSERT INTO recipes (name, kind, category, energy_required, enabled, hidden) VALUES
+        ('iron-plate','real','smelting',3.2,1,0),
+        ('craft-stone-furnace','real','crafting',0.5,1,0),
+        ('craft-speed-module-1','real','crafting',5,1,0);
+      INSERT INTO recipe_ingredients (recipe, idx, kind, name, amount) VALUES
+        ('iron-plate',0,'item','iron-ore',1),
+        ('craft-stone-furnace',0,'item','stone',5),
+        ('craft-speed-module-1',0,'item','iron-plate',5);
+      INSERT INTO recipe_products (recipe, idx, kind, name, amount) VALUES
+        ('iron-plate',0,'item','iron-plate',1),
+        ('craft-stone-furnace',0,'item','stone-furnace',1),
+        ('craft-speed-module-1',0,'item','speed-module-1',1);
+
+      -- 2 module slots (vanilla stone-furnace has none — this fixture gives it
+      -- slots on purpose, standing in for a moduled Py building)
+      INSERT INTO crafting_machines
+        (name, display, kind, crafting_speed, module_slots, energy_usage_w, energy_source)
+      VALUES
+        ('stone-furnace','Stone furnace','furnace',1,2,90000,'electric');
+      INSERT INTO machine_categories (machine, category) VALUES
+        ('stone-furnace','smelting');
+      INSERT INTO modules (name, category, hidden, eff_speed, eff_productivity, eff_consumption)
+        VALUES ('speed-module-1','speed',0,0.2,0,0.5);
+    `);
+    fx.db.close();
+    switchDatabase(fx.file);
+  });
+
+  afterEach(() => fx.cleanup());
+
+  it("submitBlock's draft auto-fills the furnace's module slots", async () => {
+    const res = await draft({ target: "iron-plate", rate: 4, recipes: ["iron-plate"] });
+    expect(res.ok).toBe(true);
+    // unmoduled this would be 12.8 (rate 4 × 3.2s/craft ÷ speed 1 — see the
+    // sibling describe block above); with 2 speed-1 modules (+40% combined)
+    // the solved count drops to 12.8 / 1.4 = 9.142857...
+    expect(res.buildings[0].count).toBeCloseTo(12.8 / 1.4, 2);
+    expect(res.modules?.["iron-plate"]).toEqual(["speed-module-1", "speed-module-1"]);
+  });
+
+  it("buildingBill's whole-machine count matches submitBlock's module-filled count, not the bare unmoduled one", async () => {
+    const d = await draft({ target: "iron-plate", rate: 4, recipes: ["iron-plate"] });
+    const b = await bill([{ target: "iron-plate", rate: 4, recipes: ["iron-plate"] }]);
+    expect(b.skipped).toEqual([]);
+    expect(b.machines).toHaveLength(1);
+    // ceil(9.142857) = 10 — NOT ceil(12.8) = 13, the pre-fix (unmoduled) answer
+    expect(b.machines[0].count).toBe(Math.ceil(d.buildings[0].count - 1e-9));
+    expect(b.machines[0].count).toBe(10);
+  });
+});

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

@@ -0,0 +1,183 @@
+/**
+ * Multi-goal + keep-in-stock block drafts (#38): submitBlock/submitPlan used to
+ * accept only a single `target`+`rate` throughput target. A construction/mall
+ * block ("keep 80 vrauks-paddock on hand") has no honest per-second rate to
+ * give it — the assistant would either fabricate one or refuse. `blockDraftInput`
+ * now also accepts a `goals` array, each entry EITHER a throughput `rate` OR a
+ * keep-in-stock `stock` (+ optional `window`, default 600s), with the solver
+ * rate DERIVED as stock/window. `goals[0]` still anchors `target`/`rate`/
+ * `targetDisplay` for back-compat with the UI card and reviseBlock/submitPlan.
+ *
+ * Fixture: two independent one-step smelting recipes (iron-plate, copper-plate)
+ * on an unmoduled stone-furnace, so the solved building count is exactly
+ * rate × energyRequired ÷ speed with no module-fill noise.
+ */
+import { afterEach, beforeEach, describe, expect, it } from "vite-plus/test";
+import { switchDatabase } from "../db/index.server.ts";
+import { type TestDb, makeTestDb } from "../db/test-helpers.ts";
+import { buildingBill, submitBlock, submitPlan } from "./agent-tools.server.ts";
+
+type Goal = { name: string; rate: number; stock?: number; window?: number };
+type Draft = {
+  ok: boolean;
+  target: string;
+  targetDisplay?: string;
+  rate: number;
+  goals: Goal[];
+  buildings: { recipe: string; machine: string; count: number }[];
+  byproducts: { good: string; rate: number | null }[];
+};
+
+// The tool schemas' real input type defaults `window` to 600 (so its OUTPUT
+// type requires the field); these test wrappers accept the looser hand-written
+// literal shape a caller would actually send (window omittable) and cast at
+// the boundary, same as the AI SDK would after applying the schema's default.
+type DraftInput = Parameters<NonNullable<typeof submitBlock.execute>>[0];
+type PlanInput = Parameters<NonNullable<typeof submitPlan.execute>>[0];
+type BillInput = Parameters<NonNullable<typeof buildingBill.execute>>[0];
+
+const draft = async (input: Record<string, unknown>): Promise<Draft> =>
+  (await submitBlock.execute!(input as DraftInput, {
+    toolCallId: "test",
+    messages: [],
+  })) as Draft;
+
+const plan = async (input: Record<string, unknown>): Promise<{ ok: boolean; blocks: Draft[] }> =>
+  (await submitPlan.execute!(input as PlanInput, { toolCallId: "test", messages: [] })) as {
+    ok: boolean;
+    blocks: Draft[];
+  };
+
+const bill = async (
+  input: Record<string, unknown>,
+): Promise<{ machines: { entity: string; count: number }[]; skipped: unknown[] }> =>
+  (await buildingBill.execute!(input as BillInput, { toolCallId: "test", messages: [] })) as {
+    machines: { entity: string; count: number }[];
+    skipped: unknown[];
+  };
+
+describe("submitBlock/submitPlan/buildingBill: multi-goal + keep-in-stock goals (#38)", () => {
+  let fx: TestDb;
+
+  beforeEach(async () => {
+    fx = await makeTestDb();
+    fx.db.exec(`
+      INSERT INTO items (name, display) VALUES
+        ('iron-ore','Iron ore'),('iron-plate','Iron plate'),
+        ('copper-ore','Copper ore'),('copper-plate','Copper plate');
+
+      INSERT INTO recipes (name, kind, category, energy_required, enabled, hidden) VALUES
+        ('iron-plate','real','smelting',3.2,1,0),
+        ('copper-plate','real','smelting',3.2,1,0);
+      INSERT INTO recipe_ingredients (recipe, idx, kind, name, amount) VALUES
+        ('iron-plate',0,'item','iron-ore',1),
+        ('copper-plate',0,'item','copper-ore',1);
+      INSERT INTO recipe_products (recipe, idx, kind, name, amount) VALUES
+        ('iron-plate',0,'item','iron-plate',1),
+        ('copper-plate',0,'item','copper-plate',1);
+
+      INSERT INTO crafting_machines
+        (name, display, kind, crafting_speed, module_slots, energy_usage_w, energy_source)
+      VALUES
+        ('stone-furnace','Stone furnace','furnace',1,0,90000,'electric');
+      INSERT INTO machine_categories (machine, category) VALUES
+        ('stone-furnace','smelting');
+    `);
+    fx.db.close();
+    switchDatabase(fx.file);
+  });
+
+  afterEach(() => fx.cleanup());
+
+  it("backward compat: the legacy target+rate shorthand still works unchanged", async () => {
+    const res = await draft({ target: "iron-plate", rate: 4, recipes: ["iron-plate"] });
+    expect(res.ok).toBe(true);
+    expect(res.target).toBe("iron-plate");
+    expect(res.rate).toBe(4);
+    expect(res.goals).toEqual([{ name: "iron-plate", rate: 4 }]);
+    expect(res.buildings[0].count).toBeCloseTo(12.8, 2);
+  });
+
+  it("a stock goal derives its solver rate as stock/window and carries stock/window in the draft", async () => {
+    const res = await draft({
+      goals: [{ name: "iron-plate", stock: 80, window: 200 }],
+      recipes: ["iron-plate"],
+    });
+    expect(res.ok).toBe(true);
+    // goals[0] still anchors target/rate/targetDisplay for back-compat
+    expect(res.target).toBe("iron-plate");
+    expect(res.rate).toBeCloseTo(0.4, 5); // 80/200
+    expect(res.goals).toEqual([{ name: "iron-plate", rate: 0.4, stock: 80, window: 200 }]);
+    // solved against the DERIVED rate (0.4/s), not a fabricated continuous one:
+    // 0.4/s x 3.2s/craft = 1.28 furnaces
+    expect(res.buildings[0].count).toBeCloseTo(1.28, 2);
+  });
+
+  it("a stock goal without an explicit window defaults to 600s (#38 STOCK_WINDOW_DEFAULT)", async () => {
+    const res = await draft({
+      goals: [{ name: "iron-plate", stock: 60 }],
+      recipes: ["iron-plate"],
+    });
+    expect(res.goals).toEqual([{ name: "iron-plate", rate: 0.1, stock: 60, window: 600 }]);
+  });
+
+  it("supports multiple goals in one block — a rate goal and a stock goal together", async () => {
+    const res = await draft({
+      goals: [
+        { name: "iron-plate", rate: 4 },
+        { name: "copper-plate", stock: 80, window: 400 },
+      ],
+      recipes: ["iron-plate", "copper-plate"],
+    });
+    expect(res.ok).toBe(true);
+    expect(res.goals).toEqual([
+      { name: "iron-plate", rate: 4 },
+      { name: "copper-plate", rate: 0.2, stock: 80, window: 400 },
+    ]);
+    const byRecipe = Object.fromEntries(res.buildings.map((b) => [b.recipe, b.count]));
+    expect(byRecipe["iron-plate"]).toBeCloseTo(12.8, 2); // 4 x 3.2
+    expect(byRecipe["copper-plate"]).toBeCloseTo(0.64, 2); // 0.2 x 3.2
+    // both goals are solver targets, not surplus — neither shows up as a byproduct
+    expect(res.byproducts.map((b) => b.good)).not.toContain("iron-plate");
+    expect(res.byproducts.map((b) => b.good)).not.toContain("copper-plate");
+  });
+
+  it("submitPlan carries each block's full goals array, including a stock goal", async () => {
+    const res = await plan({
+      title: "Mall",
+      objective: "keep some buildings on hand",
+      blocks: [
+        {
+          name: "Mall block",
+          goals: [
+            { name: "iron-plate", stock: 80, window: 400 },
+            { name: "copper-plate", rate: 1 },
+          ],
+          recipes: ["iron-plate", "copper-plate"],
+        },
+      ],
+    });
+    expect(res.ok).toBe(true);
+    expect(res.blocks).toHaveLength(1);
+    const b = res.blocks[0];
+    expect(b.target).toBe("iron-plate"); // goals[0] anchors naming/sizing
+    expect(b.rate).toBeCloseTo(0.2, 5);
+    expect(b.goals).toEqual([
+      { name: "iron-plate", rate: 0.2, stock: 80, window: 400 },
+      { name: "copper-plate", rate: 1 },
+    ]);
+  });
+
+  it("buildingBill accepts the same goals array shape and reflects the derived stock rate", async () => {
+    const res = await bill({
+      blocks: [
+        { goals: [{ name: "iron-plate", stock: 80, window: 200 }], recipes: ["iron-plate"] },
+      ],
+    });
+    expect(res.skipped).toEqual([]);
+    expect(res.machines).toHaveLength(1);
+    // 0.4/s x 3.2s = 1.28 fractional furnaces -> ceil = 2
+    expect(res.machines[0].entity).toBe("stone-furnace");
+    expect(res.machines[0].count).toBe(2);
+  });
+});