@saadnvd1/agent-os 0.3.612 → 0.3.614

package/components/SessionList/RowParts.tsx

@@ -1,5 +1,6 @@
 "use client";
 
+import { Lightbulb } from "lucide-react";
 import { useEffect, useRef, useState, type ReactNode } from "react";
 import type { SidebarRow } from "@/lib/sidebar/shelves";
 import { cn } from "@/lib/utils";
@@ -45,6 +46,21 @@ export function UnreadDot() {
   );
 }
 
+// A learning card is waiting on this session.
+export function CardBadge({ count }: { count: number }) {
+  return (
+    <span
+      data-tip="Learning card waiting: open the session to keep or drop it"
+      className="shrink-0"
+    >
+      <Lightbulb
+        aria-label={count > 1 ? `${count} learning cards` : "Learning card"}
+        className="h-3 w-3 text-amber-600 dark:text-amber-400"
+      />
+    </span>
+  );
+}
+
 export function RowRename({
   initial,
   onDone,

package/components/SessionList/SessionRow.tsx

@@ -14,6 +14,7 @@ import { compactTimeAgo } from "@/lib/session-meta";
 import { wakeLabel } from "@/lib/sidebar/snooze";
 import { sameRow, type SidebarRow } from "@/lib/sidebar/shelves";
 import { rowStatusBadge } from "@/lib/sidebar/row-badge";
+import { usePendingCardSessions } from "@/data/learning-cards";
 import { useMinuteTick } from "@/hooks/useMinuteTick";
 import { selectionStore, selectionActions } from "@/stores/sessionSelection";
 import { cn } from "@/lib/utils";
@@ -21,7 +22,7 @@ import { QuickChangeRow } from "./QuickChangeRow";
 import { useRowContext } from "./RowContext";
 import { SessionRowMenu } from "./SessionRowMenu";
 import { RowShell, type RowMenuKind } from "./RowShell";
-import { NestRail, RowDot, RowRename, UnreadDot } from "./RowParts";
+import { CardBadge, NestRail, RowDot, RowRename, UnreadDot } from "./RowParts";
 import { RowSubtitle } from "./RowSubtitle";
 import { OrchestratorAsks } from "./OrchestratorAsks";
 
@@ -63,6 +64,7 @@ export const SessionRow = memo(function SessionRow({
   };
 
   const badge = rowStatusBadge(row);
+  const cardCount = usePendingCardSessions().get(session.id) ?? 0;
 
   const menu = (kind: RowMenuKind) => (
     <SessionRowMenu
@@ -102,6 +104,7 @@ export const SessionRow = memo(function SessionRow({
                 />
               </span>
             )}
+            {cardCount > 0 && <CardBadge count={cardCount} />}
             {row.unread && !badge && <UnreadDot />}
             {isFork(session) && (
               <GitFork className="text-muted-foreground/60 h-3 w-3 shrink-0" />

package/components/SessionList/SessionShelves.tsx

@@ -11,6 +11,7 @@ import {
 import type { MachineGroup } from "@/lib/sidebar/machines";
 import { sidebarUiActions } from "@/stores/sidebarUi";
 import { cn } from "@/lib/utils";
+import { usePendingCardSessions } from "@/data/learning-cards";
 import { SessionRow } from "./SessionRow";
 import { OrchestratorPinRow, OrchestratorStartRow } from "./OrchestratorPinRow";
 import { QueuedRow } from "./QueuedRow";
@@ -125,7 +126,14 @@ export function SessionShelves({
 }) {
   const shown = shelves.done.slice(0, doneLimit(donePages));
   const hidden = shelves.done.length - shown.length;
-  const summary = doneSummary(shelves.done).text;
+  const pendingCards = usePendingCardSessions();
+  const doneCards = shelves.done.reduce(
+    (n, r) => n + (pendingCards.get(r.session.id) ?? 0),
+    0
+  );
+  const summary =
+    doneSummary(shelves.done).text +
+    (doneCards ? ` · ${doneCards} card${doneCards > 1 ? "s" : ""}` : "");
   // Live work above, what's resting below a hairline.
   const live =
     shelves.orchestrators.length +

package/data/learning-cards/index.ts

@@ -1,9 +1,12 @@
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import { toast } from "sonner";
-import type { Card } from "@/lib/learning-cards/types";
+import { useMemo } from "react";
+import type { Card, PendingCardView } from "@/lib/learning-cards/types";
 import { useExperiment } from "../experiments";
+import { orchestratorKeys } from "../orchestrators";
+import { usePollWhenOffline } from "../push/connection";
 
-export type { Card };
+export type { Card, PendingCardView };
 
 export interface CardEdits {
   lesson?: string;
@@ -12,7 +15,10 @@ export interface CardEdits {
 }
 
 export const learningCardsKeys = {
-  session: (sessionId: string) => ["learning-cards", sessionId] as const,
+  all: ["learning-cards"] as const,
+  pending: ["learning-cards", "pending"] as const,
+  session: (sessionId: string) =>
+    ["learning-cards", "session", sessionId] as const,
 };
 
 async function json<T>(res: Response): Promise<T> {
@@ -36,11 +42,39 @@ export function useLearningCards(sessionId: string) {
       ).cards,
     enabled,
     staleTime: 10_000,
-    refetchInterval: 30_000,
+    // Pushed when a card is made or decided; this is the offline fallback.
+    refetchInterval: usePollWhenOffline(60_000),
   });
 }
 
-function useDecide(sessionId: string) {
+// Every pending card, for the sidebar's badges. One request for the list.
+export function usePendingCards() {
+  const enabled = useExperiment("learning-cards");
+  return useQuery({
+    queryKey: learningCardsKeys.pending,
+    queryFn: async () =>
+      (
+        await json<{ cards: PendingCardView[] }>(
+          await fetch("/api/learning-cards")
+        )
+      ).cards,
+    enabled,
+    staleTime: 10_000,
+    refetchInterval: usePollWhenOffline(60_000),
+  });
+}
+
+export function usePendingCardSessions(): Map<string, number> {
+  const { data } = usePendingCards();
+  return useMemo(() => {
+    const m = new Map<string, number>();
+    for (const c of data ?? [])
+      m.set(c.sessionId, (m.get(c.sessionId) ?? 0) + 1);
+    return m;
+  }, [data]);
+}
+
+function useDecide() {
   const queryClient = useQueryClient();
   return useMutation({
     mutationFn: async (
@@ -54,9 +88,9 @@ function useDecide(sessionId: string) {
         })
       ),
     onSuccess: (_d, v) => {
-      queryClient.invalidateQueries({
-        queryKey: learningCardsKeys.session(sessionId),
-      });
+      // The chat's card, the sidebar badge and the Needs-you strip.
+      queryClient.invalidateQueries({ queryKey: learningCardsKeys.all });
+      queryClient.invalidateQueries({ queryKey: orchestratorKeys.all });
       // A saved recipe or a new rule shows up in their own lists.
       if (v.action === "apply") {
         queryClient.invalidateQueries({ queryKey: ["recipes"] });
@@ -68,8 +102,8 @@ function useDecide(sessionId: string) {
   });
 }
 
-export const useApplyCard = (sessionId: string) => {
-  const m = useDecide(sessionId);
+export const useApplyCard = () => {
+  const m = useDecide();
   return {
     ...m,
     apply: (id: number, edits: CardEdits = {}) =>

package/data/push/topics.ts

@@ -17,6 +17,7 @@ import { featureKeys } from "../features";
 import { archivedKeys } from "../done";
 import { awayKeys } from "../away";
 import { bookmarkKeys } from "../bookmarks/keys";
+import { learningCardsKeys } from "../learning-cards";
 
 // What each pushed topic (a table that changed, lib/db/changes.ts, or a
 // pushed view) means the browser should refetch. Only queries on screen
@@ -73,6 +74,8 @@ function keysFor(topic: string): QueryKey[] {
       return [awayKeys.all];
     case "dev_servers":
       return [devServerKeys.all];
+    case "learning_cards":
+      return [learningCardsKeys.all, orchestratorKeys.all];
     case "chat_bookmarks":
       return [bookmarkKeys.all];
     default:

package/hooks/useNeedsYou.ts

@@ -6,6 +6,7 @@ import { useSessionsQuery } from "@/data/sessions/queries";
 import { useProjectsQuery } from "@/data/projects/queries";
 import { fetchStatuses } from "@/data/statuses/queries";
 import { statusKeys } from "@/data/sessions/keys";
+import { useExperiment } from "@/data/experiments";
 import { useOrchestratorOverview } from "@/data/orchestrators";
 import {
   needsYouItems,
@@ -20,6 +21,7 @@ export function useNeedsYou(
   chatWaiting: boolean
 ): NeedsYouItem[] {
   const overview = useOrchestratorOverview(workspaceId);
+  const cardsOn = useExperiment("learning-cards");
   const { data: sessions } = useSessionsQuery();
   const { data: projects = [] } = useProjectsQuery();
   const { data: statuses } = useQuery({
@@ -45,9 +47,10 @@ export function useNeedsYou(
         questions: overview?.questions ?? [],
         dismissed: overview?.dismissed ?? [],
         tasks,
+        cards: cardsOn ? (overview?.cards ?? []) : [],
         chatWaiting,
         chatKey: `approval:${workspaceId}`,
       }),
-    [overview, tasks, chatWaiting, workspaceId]
+    [overview, tasks, cardsOn, chatWaiting, workspaceId]
   );
 }

package/lib/chat/events.ts

@@ -68,7 +68,9 @@ export type ChatOriginKind =
   // AgentOS itself: the load monitor, stacks.
   | "system"
   // The reader's own decision, made outside the composer (a plan carried out).
-  | "decision";
+  | "decision"
+  // The reader's phone: a shake report or something shared to AgentOS.
+  | "device";
 
 export interface ChatOrigin {
   kind: ChatOriginKind;

package/lib/chat/origin.ts

@@ -24,7 +24,8 @@ function fromText(text: string): ChatOrigin | null {
   return null;
 }
 
-// What sent a user item, or null when the reader typed it.
+// What sent a user item, or null when the reader typed it. A "device" origin
+// is only ever set by the server (lib/intake), so it is never read from text.
 export function originOf(item: UserItem): ChatOrigin | null {
   if (item.origin) return item.origin;
   if (item.peer)

package/lib/chat/settings.ts

@@ -66,6 +66,12 @@ function visibleCommands(caps: Capabilities): ChatCommand[] {
   );
 }
 
+// The commands already loaded for a session's folder; never loads them.
+export function cachedCommands(session: Session): ChatCommand[] {
+  const caps = registry.caps.get(capsKey(session));
+  return caps ? visibleCommands(caps) : [];
+}
+
 export function emitCapabilities(session: Session, listener?: Listener): void {
   const caps = registry.caps.get(capsKey(session));
   if (!caps) return;

package/lib/config/client-config-types.ts

@@ -26,4 +26,51 @@ export interface ClientConfig {
   taskStates: Record<string, LabelTone>;
   runStatuses: Record<string, LabelTone>;
   runTriggers: Record<string, string>;
+  features: ClientFeatures;
+  intake: IntakeLimits;
+  attachments: { max: number };
+  voice: VoiceLimits;
 }
+
+// Server kill switches for the phone's new sends.
+export interface ClientFeatures {
+  shakeToReport: boolean;
+  shareIntake: boolean;
+  voice: boolean;
+}
+
+export interface IntakeLimits {
+  maxBytes: number;
+  maxFiles: number;
+  maxInlineImages: number;
+  maxNoteChars: number;
+  screenshotMaxEdge: number;
+  logSeconds: number;
+  logMaxLines: number;
+}
+
+export interface VoiceLimits {
+  maxPhrases: number;
+  holdMinMs: number;
+  cancelSlidePx: number;
+  speakMaxChars: number;
+}
+
+export const INTAKE_LIMITS: IntakeLimits = {
+  maxBytes: 25_000_000,
+  maxFiles: 8,
+  maxInlineImages: 2,
+  maxNoteChars: 280,
+  screenshotMaxEdge: 1600,
+  logSeconds: 60,
+  logMaxLines: 200,
+};
+
+export const ATTACHMENT_LIMITS = { max: 8 };
+
+export const VOICE_LIMITS: VoiceLimits = {
+  maxPhrases: 100,
+  holdMinMs: 250,
+  cancelSlidePx: 80,
+  speakMaxChars: 300,
+};

package/lib/config/client-config.ts

@@ -7,12 +7,26 @@ import {
 import { TASK_STATE_LABELS } from "../tasks/state-labels";
 import { cachedCheck } from "../updates/check";
 import {
+  ATTACHMENT_LIMITS,
   CLIENT_CONFIG_VERSION,
+  INTAKE_LIMITS,
+  VOICE_LIMITS,
+  type ClientFeatures,
   type ClientConfig,
 } from "./client-config-types";
 
 const startedAt = new Date(Date.now() - process.uptime() * 1000).toISOString();
 
+// Off when its env switch says so, for a server that wants it dark.
+export function featuresNow(): ClientFeatures {
+  const intake = process.env.AGENTOS_INTAKE !== "off";
+  return {
+    shakeToReport: intake,
+    shareIntake: intake,
+    voice: process.env.AGENTOS_VOICE !== "off",
+  };
+}
+
 export function clientConfig(): ClientConfig {
   return {
     v: CLIENT_CONFIG_VERSION,
@@ -24,5 +38,9 @@ export function clientConfig(): ClientConfig {
     taskStates: TASK_STATE_LABELS,
     runStatuses: RUN_STATUS_LABELS,
     runTriggers: RUN_TRIGGER_LABELS,
+    features: featuresNow(),
+    intake: INTAKE_LIMITS,
+    attachments: ATTACHMENT_LIMITS,
+    voice: VOICE_LIMITS,
   };
 }

package/lib/db/changes.ts

@@ -43,6 +43,8 @@ export const TABLES_WATCHED_80 = [
 
 export const TABLES_WATCHED_CHAT_BOOKMARKS = ["chat_bookmarks"] as const;
 
+export const TABLES_WATCHED_LEARNING_CARDS = ["learning_cards"] as const;
+
 // Every table any migration watches, for the browser's topic map to cover.
 export const WATCHED_TABLES: readonly string[] = [
   ...TABLES_WATCHED_45,
@@ -52,6 +54,7 @@ export const WATCHED_TABLES: readonly string[] = [
   ...TABLES_WATCHED_78,
   ...TABLES_WATCHED_80,
   ...TABLES_WATCHED_CHAT_BOOKMARKS,
+  ...TABLES_WATCHED_LEARNING_CARDS,
 ];
 
 export function installChangeTriggers(

package/lib/db/index.ts

@@ -3,6 +3,7 @@ import path from "path";
 import fs from "fs";
 import { createSchema } from "./schema";
 import { runMigrations } from "./migrations";
+import { dbPath } from "./path";
 
 // Re-export types and queries
 export * from "./types";
@@ -11,7 +12,7 @@ export * from "./lumifyhub";
 export * from "./lumifyhub-docs";
 export * from "./stacks";
 
-const DB_PATH = process.env.DB_PATH || path.join(process.cwd(), "agent-os.db");
+const DB_PATH = dbPath();
 const LOCK_PATH = DB_PATH + ".init-lock";
 
 // Simple file-based lock for initialization

package/lib/db/migrations/20261014T2300_learning_cards_watch.ts

@@ -0,0 +1,18 @@
+import type { Migration } from "../migration-types";
+import {
+  installChangeTriggers,
+  TABLES_WATCHED_LEARNING_CARDS,
+} from "../changes";
+
+export default {
+  key: "20261014T2300_learning_cards_watch",
+  up: (db) => {
+    // A card decided in one place disappears from every open screen.
+    // Additive: an index and change triggers.
+    db.exec(
+      `CREATE INDEX IF NOT EXISTS idx_learning_cards_pending
+         ON learning_cards(status, created_at)`
+    );
+    installChangeTriggers(db, TABLES_WATCHED_LEARNING_CARDS);
+  },
+} satisfies Migration;

package/lib/db/path.ts

@@ -0,0 +1,7 @@
+import path from "path";
+
+export const dbPath = (): string =>
+  process.env.DB_PATH || path.join(process.cwd(), "agent-os.db");
+
+// Where AgentOS keeps its own files beside the database.
+export const dataRoot = (): string => path.dirname(path.resolve(dbPath()));

package/lib/intake/intake.ts

@@ -0,0 +1,250 @@
+import fs from "fs";
+import path from "path";
+import { dataRoot } from "../db/path";
+import type { ChatImage } from "../chat/events";
+import { chatState, sendChat } from "../chat/runner";
+import { ensureOrchestrator, getOrchestrator } from "../orchestrator/home";
+import { getWorkspace } from "../workspaces";
+import { INTAKE_LIMITS, MAX_INLINE_IMAGE_BYTES } from "./limits";
+import { buildIntakeMessage, type IntakeMeta } from "./message";
+import { sniff } from "./sniff";
+
+export class IntakeError extends Error {
+  constructor(
+    public status: number,
+    message: string
+  ) {
+    super(message);
+  }
+}
+
+export interface IntakeResult {
+  id: string;
+  sessionId: string | null;
+  delivered: "sent" | "queued";
+  dir: string;
+}
+
+export interface IntakeFile {
+  name: string;
+  data: Buffer;
+}
+
+const ID = /^[A-Za-z0-9-]{8,64}$/;
+const DAY = 86_400_000;
+
+const segment = (s: string) => s.replace(/[^\w-]/g, "_");
+const day = (t: number) => new Date(t).toISOString().slice(0, 10);
+
+const workspaceRoot = (workspaceId: string) =>
+  path.join(dataRoot(), "intake", segment(workspaceId));
+
+/** A phone's filename as one safe path segment. */
+export function safeName(name: string, taken: Set<string>, n: number): string {
+  let base = path.basename(name.replace(/\\/g, "/"));
+  base = base
+    .replace(/[^a-zA-Z0-9.-]/g, "_")
+    .replace(/^\.+/, "")
+    .slice(0, 80);
+  if (!base) base = `file-${n}`;
+  let out = base;
+  for (let i = 2; taken.has(out); i++) {
+    const dot = base.lastIndexOf(".");
+    out =
+      dot > 0 ? `${base.slice(0, dot)}-${i}${base.slice(dot)}` : `${base}-${i}`;
+  }
+  taken.add(out);
+  return out;
+}
+
+function checkMeta(meta: IntakeMeta) {
+  if (!meta || typeof meta !== "object") throw new IntakeError(400, "Bad meta");
+  if (typeof meta.clientId !== "string" || !ID.test(meta.clientId))
+    throw new IntakeError(400, "clientId must be a uuid");
+  if (meta.kind !== "report" && meta.kind !== "share")
+    throw new IntakeError(400, "kind must be report or share");
+  if (meta.note !== undefined) {
+    if (typeof meta.note !== "string") throw new IntakeError(400, "Bad note");
+    if (meta.note.length > INTAKE_LIMITS.maxNoteChars)
+      throw new IntakeError(413, "Note is too long");
+  }
+}
+
+// An earlier request with this clientId, today or just before midnight.
+function existing(
+  workspaceId: string,
+  clientId: string,
+  now: number
+): string | null {
+  for (const t of [now, now - DAY]) {
+    const dir = path.join(workspaceRoot(workspaceId), day(t), clientId);
+    if (fs.existsSync(dir)) return dir;
+  }
+  return null;
+}
+
+function earlier(dir: string, clientId: string, workspaceId: string) {
+  try {
+    return JSON.parse(
+      fs.readFileSync(path.join(dir, "result.json"), "utf8")
+    ) as IntakeResult;
+  } catch {
+    // The first request is still delivering.
+    return {
+      id: clientId,
+      sessionId: getOrchestrator(workspaceId)?.id ?? null,
+      delivered: "queued",
+      dir,
+    } satisfies IntakeResult;
+  }
+}
+
+/** Saves what a phone sent and hands it to the workspace's orchestrator. */
+export async function receiveIntake(input: {
+  workspaceId: string;
+  deviceName: string;
+  meta: IntakeMeta;
+  files: IntakeFile[];
+  now?: number;
+}): Promise<IntakeResult & { duplicate: boolean }> {
+  const { workspaceId, deviceName, meta, files } = input;
+  const now = input.now ?? Date.now();
+  if (!getWorkspace(workspaceId))
+    throw new IntakeError(404, "Unknown workspace");
+  checkMeta(meta);
+  if (files.length > INTAKE_LIMITS.maxFiles)
+    throw new IntakeError(413, "Too many files");
+  const total = files.reduce((n, f) => n + f.data.length, 0);
+  if (total > INTAKE_LIMITS.maxBytes) throw new IntakeError(413, "Too large");
+  const sniffed = files.map((f) => {
+    const kind = sniff(f.data, f.name);
+    if (!kind)
+      throw new IntakeError(415, `Can't take ${path.basename(f.name)}`);
+    return kind;
+  });
+
+  const prior = existing(workspaceId, meta.clientId, now);
+  if (prior)
+    return { ...earlier(prior, meta.clientId, workspaceId), duplicate: true };
+
+  const parent = path.join(workspaceRoot(workspaceId), day(now));
+  const dir = path.join(parent, meta.clientId);
+  fs.mkdirSync(parent, { recursive: true, mode: 0o700 });
+  try {
+    fs.mkdirSync(dir, { mode: 0o700 });
+  } catch (e) {
+    if ((e as NodeJS.ErrnoException).code === "EEXIST")
+      return { ...earlier(dir, meta.clientId, workspaceId), duplicate: true };
+    throw e;
+  }
+
+  try {
+    const write = (name: string, data: string | Buffer) =>
+      fs.writeFileSync(path.join(dir, name), data, { mode: 0o600 });
+    write(
+      "meta.json",
+      JSON.stringify({ ...meta, deviceName, receivedAt: now }, null, 2)
+    );
+    if (meta.kind === "report")
+      write("report.json", JSON.stringify(meta.report ?? {}, null, 2));
+    const taken = new Set([
+      "meta.json",
+      "report.json",
+      "logs.txt",
+      "result.json",
+    ]);
+    let logs: string | undefined;
+    const saved: { path: string; name: string; i: number }[] = [];
+    files.forEach((f, i) => {
+      if (f.name === "logs.txt" && logs === undefined) {
+        logs = f.data
+          .toString("utf8")
+          .split(/\r?\n/)
+          .slice(-INTAKE_LIMITS.logMaxLines)
+          .join("\n");
+        write("logs.txt", logs);
+        return;
+      }
+      const name = safeName(f.name, taken, i + 1);
+      write(name, f.data);
+      saved.push({ path: path.join(dir, name), name, i });
+    });
+
+    const images: ChatImage[] = saved
+      .filter(
+        (s) =>
+          sniffed[s.i].kind === "image" &&
+          sniffed[s.i].mediaType !== "image/heic" &&
+          files[s.i].data.length <= MAX_INLINE_IMAGE_BYTES
+      )
+      .sort(
+        (a, b) =>
+          Number(/^screenshot/.test(b.name)) -
+          Number(/^screenshot/.test(a.name))
+      )
+      .slice(0, INTAKE_LIMITS.maxInlineImages)
+      .map((s) => ({
+        mediaType: sniffed[s.i].mediaType,
+        data: files[s.i].data.toString("base64"),
+      }));
+
+    const { text, body } = buildIntakeMessage({
+      meta,
+      deviceName,
+      dir,
+      files: saved.map((s) => s.path),
+      logs,
+    });
+    const orchestrator = ensureOrchestrator(workspaceId);
+    const state = chatState(orchestrator.id);
+    const delivered =
+      state === "running" || state === "waiting" ? "queued" : "sent";
+    await sendChat(orchestrator.id, {
+      id: `intake-${meta.clientId}`,
+      text,
+      images: images.length ? images : undefined,
+      queue: true,
+      origin: { kind: "device", label: deviceName, body },
+    });
+    const result: IntakeResult = {
+      id: meta.clientId,
+      sessionId: orchestrator.id,
+      delivered,
+      dir,
+    };
+    write("result.json", JSON.stringify(result));
+    return { ...result, duplicate: false };
+  } catch (e) {
+    // So a retry can deliver it.
+    fs.rmSync(dir, { recursive: true, force: true });
+    throw e;
+  }
+}
+
+/** The request's form, refused once its body passes `max` bytes. */
+export async function cappedFormData(
+  request: Request,
+  max: number
+): Promise<FormData> {
+  const declared = Number(request.headers.get("content-length") ?? 0);
+  if (declared > max) throw new IntakeError(413, "Too large");
+  if (!request.body) throw new IntakeError(400, "No body");
+  let size = 0;
+  const counted = request.body.pipeThrough(
+    new TransformStream<Uint8Array, Uint8Array>({
+      transform(chunk, controller) {
+        size += chunk.byteLength;
+        if (size > max) controller.error(new IntakeError(413, "Too large"));
+        else controller.enqueue(chunk);
+      },
+    })
+  );
+  try {
+    return await new Response(counted, {
+      headers: { "content-type": request.headers.get("content-type") ?? "" },
+    }).formData();
+  } catch (e) {
+    if (e instanceof IntakeError) throw e;
+    throw new IntakeError(size > max ? 413 : 400, "Bad upload");
+  }
+}