intake: POST /api/intake router + PUT /api/transactions/[id]/line-items (plan §11 C1, C2)

One upload point, every applicable step. Persist the batch, classify each
file, ONE LiteLLM call (cloud-budget, temperature 0, strict json_schema; PDFs
as unpdf text, never pixels) with an order-item prompt that keeps names
verbatim, header (merchant, date, total), merchant pattern
(coles|woolworths|woolies|aldi|iga|foodworks|costco) -> grocery | food | ask,
exact (platform, merchant, date, total) match against transactions +
expense_metadata, then act:

- food + unique match  -> replace line_items via the C2 path, 'enriched'
- food + miss/ambiguity -> 'candidates' (same merchant ±3d) with
  intake_use_candidate / intake_create buttons; never auto-creates
- grocery              -> original files to pantry POST /api/capture with
  finance_target_transaction_id + finance_action enrich|create (C3);
  409 -> 'duplicate'
- ask / needs_header / held / duplicate / unsupported as replies, not writes

Reconciliation is against the printed item subtotal (a delivery total is
items + fees - promotions: 18.94 of Coles lines settled at 5.74),  or
2%, else 'held'. Originals are kept under INTAKE_FILE_DIR by sha256 so a later
'Groceries' tap can still forward them.

C2 is an idempotent replace on transaction_id = :id OR
matched_transaction_id = :id, accepts INTAKE_TOKEN or RECEIPT_INGEST_TOKEN,
creates the expense_metadata row when absent, 404 when the transaction does
not exist, returns {previous_line_items, line_items} so pantry's undo is the
same call with the previous list.

src/lib/intake-actions.ts

@@ -0,0 +1,118 @@
+import { loadFiles } from "@/lib/intake-files";
+import type { PantryForward } from "@/lib/intake-pantry";
+import type { IntakeSource } from "@/lib/intake-rules";
+import {
+  createFromBatch,
+  loadBatch,
+  rememberKind,
+  resolvedCard,
+  routeFood,
+  routeGrocery,
+  type BatchRow,
+  type RouteContext,
+} from "@/lib/intake-router";
+import { replaceLineItems, TransactionNotFoundError } from "@/lib/line-items";
+import { enrichedCard, errorCard, type Block } from "@/lib/intake-blocks";
+import { queryRaw } from "@/lib/db";
+
+/**
+ * The four intake taps (plan §11 C5), as one function the Slack route calls.
+ *
+ * Every tap acts on the persisted batch, never on the card's text. A tap on a
+ * batch that is already resolved returns its current card rather than acting
+ * twice — a pressed button that looked dead and got pressed again is how three
+ * splits were lost on the order nudge, and the same shape applies here.
+ */
+
+export const INTAKE_ACTIONS = ["intake_use_candidate", "intake_create", "intake_grocery", "intake_meal"] as const;
+export type IntakeActionId = (typeof INTAKE_ACTIONS)[number];
+
+export function isIntakeAction(id: unknown): id is IntakeActionId {
+  return typeof id === "string" && (INTAKE_ACTIONS as readonly string[]).includes(id);
+}
+
+export type IntakeActionValue = { batch_id?: string; transaction_id?: number };
+
+export function parseActionValue(raw: unknown): IntakeActionValue {
+  if (typeof raw !== "string") return {};
+  try {
+    const v = JSON.parse(raw) as IntakeActionValue;
+    return v && typeof v === "object" ? v : {};
+  } catch {
+    return {};
+  }
+}
+
+const note = (text: string): { blocks: Block[]; text: string; replace: boolean } => ({
+  text,
+  blocks: [{ type: "section", text: { type: "mrkdwn", text } }],
+  replace: false,
+});
+
+const ctxFor = (batch: BatchRow): RouteContext | null =>
+  batch.header
+    ? {
+        batchId: batch.id,
+        source: batch.source as IntakeSource,
+        sharedBy: batch.shared_by,
+        platform: batch.header.platform,
+        header: batch.header,
+        items: batch.items ?? [],
+      }
+    : null;
+
+export async function handleIntakeAction(
+  actionId: IntakeActionId,
+  value: IntakeActionValue,
+  deps: { pantry: PantryForward }
+): Promise<{ blocks: Block[]; text: string; replace: boolean }> {
+  if (!value.batch_id) return note("That button carried no batch id — I can't tell which upload it was.");
+  const batch = await loadBatch(value.batch_id);
+  if (!batch) return note("I can't find that upload any more.");
+  if (batch.status === "enriched" || batch.status === "created" || batch.status === "forwarded_to_pantry") {
+    return { ...resolvedCard(batch), replace: true };
+  }
+  const ctx = ctxFor(batch);
+  if (!ctx) return note("That upload never got a readable header — share it again with the top of the screen.");
+
+  try {
+    if (actionId === "intake_use_candidate") {
+      if (!Number.isInteger(value.transaction_id)) return note("That button carried no transaction id.");
+      const txnId = value.transaction_id as number;
+      await replaceLineItems(txnId, ctx.items, { source: "intake", platform: ctx.platform, batchId: batch.id });
+      await queryRaw(
+        `UPDATE intake_batches SET status = 'enriched', kind = COALESCE(kind, 'food'), transaction_id = $2, resolved_at = now() WHERE id = $1::uuid`,
+        [batch.id, txnId]
+      );
+      return {
+        ...enrichedCard({ batchId: batch.id, merchant: ctx.header.merchant, total: ctx.header.total, orderDate: ctx.header.order_date, platform: ctx.platform, itemCount: ctx.items.length, transactionId: txnId }),
+        replace: true,
+      };
+    }
+
+    if (actionId === "intake_create") {
+      const kind = batch.kind === "grocery" ? "grocery" : "food";
+      const r = await createFromBatch(batch, kind);
+      return { blocks: r.slack_blocks ?? [], text: r.text, replace: true };
+    }
+
+    if (actionId === "intake_meal") {
+      await rememberKind(ctx.header.merchant, "food");
+      const r = await routeFood(ctx);
+      return { blocks: r.slack_blocks ?? [], text: r.text, replace: true };
+    }
+
+    // intake_grocery
+    await rememberKind(ctx.header.merchant, "grocery");
+    const files = await loadFiles(batch.file_sha256);
+    if (!files.length) {
+      return note("I remembered that as groceries, but the original files are gone — share it again and it will go straight to the pantry board.");
+    }
+    const r = await routeGrocery(ctx, files, deps.pantry);
+    return { blocks: r.slack_blocks ?? [], text: r.text, replace: r.status !== "error" };
+  } catch (e) {
+    if (e instanceof TransactionNotFoundError) return note("That transaction is no longer in the ledger.");
+    const detail = e instanceof Error ? e.message : String(e);
+    return { ...errorCard(detail), replace: false };
+  }
+}