feat(gemini): Skiva 1 – Gemini 2.5 Flash som lärar-tier för kylskåpsskanning

- Gemini-adapter bakom AamosClient-interface (AAMOS_MODE=gemini)
- Serversida/worker: hämtar bild, anropar Gemini, mappar mot canonical_ingredients
- Kostnad/tokens bokförs i ai_usage_counters; global dagsbudget via BudgetStore
- Redis-backed budget i worker, in-memory i tester
- Migration 0019: ai_cost_usd_microcents
- Hermetiska tester med inspelad fixture; separat pnpm eval:scan
- docs/09 uppdaterad ärligt: AAMOS-status, Gemini-flöde, säkerhet/kostnad
- REQUIRE_REAL=1 stödjer AAMOS_MODE=gemini; deploy-grind uppdaterad

apps/worker/src/processors/scans.ts

@@ -1,9 +1,13 @@
-import { eq } from "drizzle-orm";
+import { eq, sql } from "drizzle-orm";
 import { schema } from "@app/database";
-import type { AamosTaskType } from "@app/ai-contracts";
+import type { AamosResult, AamosTaskType, DetectedItem } from "@app/ai-contracts";
 import type { WorkerContext } from "../context.js";
 import { getLocaleContext } from "../locale.js";
 import type { LocaleContext } from "@app/shared-types";
+function currentMonth(): string {
+  const d = new Date();
+  return `${d.getUTCFullYear()}-${String(d.getUTCMonth() + 1).padStart(2, "0")}`;
+}
 
 /**
  * Bild-/OCR-jobb (spec §54): hämtar scan_job, anropar AAMOS med kontraktvaliderad
@@ -51,11 +55,21 @@ export async function processScanJob(ctx: WorkerContext, scanJobId: string): Pro
     return;
   }
 
+  let output = result.output as Record<string, unknown>;
+
+  // SKIVA 1: mappa lagrade bilders detekterade namn mot kanoniska ingredienser.
+  if (
+    (job.jobType === "ANALYZE_FRIDGE_IMAGE" || job.jobType === "ANALYZE_PANTRY_IMAGE") &&
+    Array.isArray((output as { items?: unknown }).items)
+  ) {
+    output = await mapDetectedItemsToCanonical(ctx, output);
+  }
+
   await ctx.db
     .update(schema.scanJobs)
     .set({
       status: "awaiting_confirmation",
-      result: result.output as Record<string, unknown>,
+      result: output,
       modelVersion: result.modelVersion ?? null,
       promptVersion: result.promptVersion ?? null,
       latencyMs: result.latencyMs ?? Date.now() - started,
@@ -64,9 +78,12 @@ export async function processScanJob(ctx: WorkerContext, scanJobId: string): Pro
     })
     .where(eq(schema.scanJobs.id, scanJobId));
 
+  // Bokför verklig AI-kostnad/tokens utan PII (spec §45).
+  await recordAiUsage(ctx, job.userId, result);
+
   // MEAL_PHOTO_ANALYZED-event för tallriksfoton (spec §55)
   if (job.jobType === "ANALYZE_MEAL_IMAGE") {
-    const output = result.output as {
+    const mealOutput = output as {
       kcalRange?: { mostLikely: number } | null;
       matchesRecipeContext?: boolean | null;
     };
@@ -76,8 +93,8 @@ export async function processScanJob(ctx: WorkerContext, scanJobId: string): Pro
       householdId: job.householdId,
       payload: {
         scanJobId,
-        matched: output.matchesRecipeContext ?? false,
-        kcalMostLikely: output.kcalRange?.mostLikely ?? null,
+        matched: mealOutput.matchesRecipeContext ?? false,
+        kcalMostLikely: mealOutput.kcalRange?.mostLikely ?? null,
       },
     });
   }
@@ -176,3 +193,130 @@ async function loadConsentFlags(ctx: WorkerContext, userId: string) {
     imageTraining: get("image_training"),
   };
 }
+
+// ---------------------------------------------------------------------------
+// Kanonisk ingrediensmappning (SKIVA 1). AI föreslår, vi matchar mjukt,
+// användaren bekräftar alltid innan commit.
+// ---------------------------------------------------------------------------
+
+interface CanonicalIndex {
+  id: string;
+  nameSv: string;
+  nameEn: string;
+  aliases: string[];
+}
+
+async function mapDetectedItemsToCanonical(
+  ctx: WorkerContext,
+  output: Record<string, unknown>,
+): Promise<Record<string, unknown>> {
+  const items = (output as { items: DetectedItem[] }).items;
+  if (!items.length) return output;
+
+  const index = await loadCanonicalIndex(ctx);
+  const mapped = items.map((item) => {
+    const match = findBestCanonicalMatch(item.detectedName, index);
+    return {
+      ...item,
+      canonicalIngredientId: match?.id ?? null,
+      requiresConfirmation: match == null || item.confidence < 0.92,
+    };
+  });
+
+  return { ...output, items: mapped };
+}
+
+async function loadCanonicalIndex(ctx: WorkerContext): Promise<CanonicalIndex[]> {
+  return ctx.db
+    .select({
+      id: schema.canonicalIngredients.id,
+      nameSv: schema.canonicalIngredients.nameSv,
+      nameEn: schema.canonicalIngredients.nameEn,
+      aliases: schema.canonicalIngredients.aliases,
+    })
+    .from(schema.canonicalIngredients);
+}
+
+function findBestCanonicalMatch(
+  detectedName: string,
+  index: CanonicalIndex[],
+): CanonicalIndex | null {
+  const query = detectedName.toLowerCase();
+  let best: { item: CanonicalIndex; score: number } | null = null;
+
+  for (const item of index) {
+    const score = scoreMatch(query, item);
+    if (score > 0 && (!best || score > best.score)) {
+      best = { item, score };
+    }
+  }
+
+  // Threshold: require a strong token overlap or exact substring.
+  if (!best || best.score < 0.35) return null;
+  return best.item;
+}
+
+function scoreMatch(query: string, item: CanonicalIndex): number {
+  const candidates = [
+    item.nameSv.toLowerCase(),
+    item.nameEn.toLowerCase(),
+    ...item.aliases.map((a) => a.toLowerCase()),
+  ];
+
+  let max = 0;
+  const queryTokens = tokenize(query);
+
+  for (const cand of candidates) {
+    if (cand === query) return 1;
+    if (cand.includes(query) || query.includes(cand)) max = Math.max(max, 0.85);
+
+    const candTokens = tokenize(cand);
+    const intersection = queryTokens.filter((t) => candTokens.includes(t));
+    if (intersection.length > 0) {
+      const overlap = intersection.length / Math.max(queryTokens.length, candTokens.length);
+      max = Math.max(max, overlap);
+    }
+  }
+
+  return max;
+}
+
+function tokenize(text: string): string[] {
+  return text
+    .toLowerCase()
+    .replace(/[^a-zåäö0-9\s]/g, " ")
+    .split(/\s+/)
+    .filter((t) => t.length > 1);
+}
+
+// ---------------------------------------------------------------------------
+// AI-kostnadsbokföring utan PII.
+// ---------------------------------------------------------------------------
+
+async function recordAiUsage(ctx: WorkerContext, userId: string, result: AamosResult<AamosTaskType>): Promise<void> {
+  const costUsd = result.costUsd ?? 0;
+  const tokensIn = result.inputTokens ?? 0;
+  const tokensOut = result.outputTokens ?? 0;
+  const microcents = Math.round(costUsd * 100_000_000);
+  const month = currentMonth();
+
+  await ctx.db
+    .insert(schema.aiUsageCounters)
+    .values({
+      userId,
+      month,
+      aiScans: 1,
+      aiTokensIn: tokensIn,
+      aiTokensOut: tokensOut,
+      aiCostUsdMicrocents: microcents,
+    })
+    .onConflictDoUpdate({
+      target: [schema.aiUsageCounters.userId, schema.aiUsageCounters.month],
+      set: {
+        aiScans: sql`${schema.aiUsageCounters.aiScans} + 1`,
+        aiTokensIn: sql`${schema.aiUsageCounters.aiTokensIn} + ${tokensIn}`,
+        aiTokensOut: sql`${schema.aiUsageCounters.aiTokensOut} + ${tokensOut}`,
+        aiCostUsdMicrocents: sql`${schema.aiUsageCounters.aiCostUsdMicrocents} + ${microcents}`,
+      },
+    });
+}