perf(upload): instant save + live agents after every file

- Compress phone photos in the browser before PUT (smaller, faster)
- Mark paper saved on confirm; OCR/notice AI continues in background
- Dual agent wake: in-process drain + HTTP /internal/jobs/process
- Cron job drain every 5 minutes so the queue cannot sleep long

Author: thribhuvan003

.github/workflows/cron.yml

@@ -14,7 +14,7 @@ permissions:
 
 on:
   schedule:
-    - cron: "*/10 * * * *" # every 10 minutes (GitHub Actions minimum is 5)
+    - cron: "*/5 * * * *" # every 5 minutes (GitHub Actions minimum is 5)
   workflow_dispatch: {}
 
 concurrency:

CHANGELOG.md

@@ -4,6 +4,14 @@ All notable product changes are documented here. The project follows a pre-1.0,
 
 ## Unreleased
 
+### Performance
+
+- Client compresses phone photos before upload (faster PUT + confirm).
+- Upload UI finishes on confirm; OCR/notice AI runs in background (no 60s spinner).
+- Dual job kick: in-process + HTTP wake of `/internal/jobs/process` so agents never sleep on Hobby.
+- GitHub Actions job drain every 5 minutes (was 10).
+
+
 ### Performance
 
 - Fix /healthz soft-404 by rewriting in proxy.ts before next-intl locale routing.

app/api/v1/cases/[id]/evidence/[eid]/confirm/route.ts

@@ -1,7 +1,7 @@
 import { NextRequest, after } from "next/server";
 import { assertCaseAccess, requireRequestAuth } from "@/lib/api/case-access";
 import { enqueueAgentJob } from "@/lib/jobs/enqueue";
-import { kickPendingJobs } from "@/lib/jobs/kick";
+import { kickPendingJobs, httpKickJobWorker } from "@/lib/jobs/kick";
 import { isValidSha256 } from "@/lib/evidence/sha256";
 import {
   EVIDENCE_BUCKET,
@@ -270,6 +270,8 @@ export async function POST(request: NextRequest, context: RouteContext) {
       } catch {
         // Job stays pending for the cron sweeper.
       }
+      // Separate worker so AI is never stuck waiting for the next GitHub cron.
+      void httpKickJobWorker(8);
     };
 
     try {

components/escalations/MarkSentForm.tsx

@@ -6,6 +6,7 @@ import { Loader2 } from 'lucide-react';
 import { cn } from '@/lib/ui/cn';
 import { computeSha256HexInBrowser } from '@/lib/evidence/sha256';
 import { validateUploadFile } from '@/lib/evidence/validate-file';
+import { prepareFileForUpload } from '@/lib/evidence/compress-for-upload';
 import { track } from '@/lib/analytics/events';
 
 type MarkSentFormProps = {
@@ -62,14 +63,22 @@ export function MarkSentForm({
 
     setPhase('uploading');
     try {
+      let uploadFile = proofFile;
+      try {
+        uploadFile = await prepareFileForUpload(proofFile);
+      } catch {
+        uploadFile = proofFile;
+      }
+      const uploadMime = uploadFile.type || proofFile.type || 'application/octet-stream';
+
       const urlRes = await fetch(`/api/v1/cases/${caseId}/evidence/upload-url`, {
         method: 'POST',
         headers: jsonHeaders,
         body: JSON.stringify({
           evidence_type: 'letter_sent_proof',
-          filename: proofFile.name,
-          mime_type: proofFile.type,
-          file_size_bytes: proofFile.size,
+          filename: uploadFile.name,
+          mime_type: uploadMime,
+          file_size_bytes: uploadFile.size,
         }),
       });
       const urlJson = await urlRes.json();
@@ -79,14 +88,14 @@ export function MarkSentForm({
 
       const putRes = await fetch(urlJson.upload_url, {
         method: 'PUT',
-        headers: { 'Content-Type': proofFile.type },
-        body: proofFile,
+        headers: { 'Content-Type': uploadMime },
+        body: uploadFile,
       });
       if (!putRes.ok) {
         throw new Error(t('uploadFailed'));
       }
 
-      const sha256 = await computeSha256HexInBrowser(proofFile);
+      const sha256 = await computeSha256HexInBrowser(uploadFile);
       const confirmRes = await fetch(
         `/api/v1/cases/${caseId}/evidence/${urlJson.evidence_id}/confirm`,
         {

components/evidence/PapersChecklist.tsx

@@ -7,6 +7,7 @@ import { Loader2 } from "lucide-react";
 import { computeSha256HexInBrowser } from "@/lib/evidence/sha256";
 import { resolveEvidenceMime } from "@/lib/evidence/accepted-mime";
 import { validateUploadFile } from "@/lib/evidence/validate-file";
+import { prepareFileForUpload } from "@/lib/evidence/compress-for-upload";
 import { classifyDoc, type DocClass } from "@/lib/evidence/readability";
 import type { PaperDocDef } from "@/lib/intake/paper-display";
 
@@ -101,10 +102,9 @@ const DEFAULT_EXTRA_DOCS: PaperDocDef[] = [
   },
 ];
 
-// Snappier feedback: the verify API itself is ~0.5s, so poll fast early. Total
-// window stays ~60s (40 × 1.5s) before the calm background-check fallback.
-const POLL_INTERVAL_MS = 1500;
-const POLL_MAX_ATTEMPTS = 40;
+// Fast early polls while AI runs in after(); total window ~45s then background.
+const POLL_INTERVAL_MS = 800;
+const POLL_MAX_ATTEMPTS = 55;
 
 function docClassOf(v: PaperVerification): DocClass | null {
   if (!v) return null;
@@ -236,12 +236,19 @@ export function PapersChecklist({
       patchRow(type, { status: "error", error: fileProblem });
       return;
     }
-    const mimeType = resolveEvidenceMime(file);
+    // Shrink phone photos before hash/PUT so upload + confirm are not multi-MB.
+    let uploadFile = file;
+    try {
+      uploadFile = await prepareFileForUpload(file);
+    } catch {
+      uploadFile = file;
+    }
+    const mimeType = resolveEvidenceMime(uploadFile);
 
     // Compute the hash up front so the same file can't be added to two slots.
     let sha256: string;
     try {
-      sha256 = await computeSha256HexInBrowser(file);
+      sha256 = await computeSha256HexInBrowser(uploadFile);
     } catch {
       patchRow(type, { status: "error", error: t("fileReadError") });
       return;
@@ -272,9 +279,9 @@ export function PapersChecklist({
           headers: authHeaders(),
           body: JSON.stringify({
             evidence_type: type,
-            filename: file.name,
+            filename: uploadFile.name,
             mime_type: mimeType,
-            file_size_bytes: file.size,
+            file_size_bytes: uploadFile.size,
           }),
         },
       );
@@ -285,7 +292,7 @@ export function PapersChecklist({
       const putRes = await fetch(urlJson.upload_url, {
         method: "PUT",
         headers: { "Content-Type": mimeType },
-        body: file,
+        body: uploadFile,
       });
       if (!putRes.ok) throw new Error(t("storageError"));
 
@@ -309,36 +316,38 @@ export function PapersChecklist({
 
       router.refresh();
 
-      if (!isCore) {
-        // Extras show a simple "Added" — the seal + background check still run.
-        patchRow(type, { status: "done", pending: true });
-        return;
-      }
-
-      patchRow(type, { status: "checking" });
-      const verification = await pollVerification(urlJson.evidence_id);
-      if (verification === "timeout") {
-        patchRow(type, { status: "done", pending: true, verification: null });
-      } else {
-        patchRow(type, { status: "done", verification, pending: false });
-      }
-
-      if (type === "freeze_sms") {
-        // Deliver the "AI explains your notice" promise — advisory, never blocks.
-        try {
-          await fetch(`/api/v1/cases/${caseId}/notice-analysis`, {
-            method: "POST",
-            headers: authHeaders(),
-            body: JSON.stringify({
-              input_kind: "image",
-              evidence_id: urlJson.evidence_id,
-            }),
-          });
-        } catch {
-          // best-effort — the papers page still works without the explanation
+      // Upload is DONE as soon as confirm returns. AI/OCR continues on the
+      // server (after() + job queue) — do not block the user on model latency.
+      patchRow(type, { status: "done", pending: true, verification: null });
+
+      const evidenceId = urlJson.evidence_id as string;
+      void (async () => {
+        if (isCore) {
+          const verification = await pollVerification(evidenceId);
+          if (verification !== "timeout") {
+            patchRow(type, {
+              status: "done",
+              verification,
+              pending: false,
+            });
+            router.refresh();
+          }
         }
-      }
-      router.refresh();
+        if (type === "freeze_sms") {
+          try {
+            await fetch(`/api/v1/cases/${caseId}/notice-analysis`, {
+              method: "POST",
+              headers: authHeaders(),
+              body: JSON.stringify({
+                input_kind: "image",
+                evidence_id: evidenceId,
+              }),
+            });
+          } catch {
+            // best-effort advisory — papers page still works without it
+          }
+        }
+      })();
     } catch (error) {
       patchRow(type, {
         status: "error",

lib/evidence/compress-for-upload.ts

@@ -0,0 +1,78 @@
+/**
+ * Browser-side resize before PUT so multi‑MB phone photos (often 4–12 MB)
+ * become ~150–400 KB JPEGs. That speeds storage upload, server confirm
+ * re-download/hash, and vision OCR payload size.
+ *
+ * PDFs and already-small images pass through unchanged. HEIC that the browser
+ * cannot decode falls back to the original file (server sharp still handles it).
+ */
+
+const MAX_EDGE = 1600;
+const JPEG_QUALITY = 0.82;
+/** Skip work when the file is already light enough for a fast path. */
+const SKIP_UNDER_BYTES = 450_000;
+
+function isPdf(file: File): boolean {
+  return (
+    file.type === "application/pdf" ||
+    file.name.toLowerCase().endsWith(".pdf")
+  );
+}
+
+function isLikelyImage(file: File): boolean {
+  if (file.type.startsWith("image/")) return true;
+  return /\.(jpe?g|png|webp|heic|heif|gif)$/i.test(file.name);
+}
+
+/**
+ * @returns A File ready to hash + upload (possibly compressed JPEG).
+ */
+export async function prepareFileForUpload(file: File): Promise<File> {
+  if (isPdf(file)) return file;
+  if (!isLikelyImage(file)) return file;
+  if (file.size > 0 && file.size <= SKIP_UNDER_BYTES) return file;
+
+  // createImageBitmap handles JPEG/PNG/WebP in modern browsers; HEIC varies.
+  let bitmap: ImageBitmap;
+  try {
+    bitmap = await createImageBitmap(file);
+  } catch {
+    return file;
+  }
+
+  try {
+    const scale = Math.min(1, MAX_EDGE / Math.max(bitmap.width, bitmap.height));
+    const width = Math.max(1, Math.round(bitmap.width * scale));
+    const height = Math.max(1, Math.round(bitmap.height * scale));
+
+    const canvas = document.createElement("canvas");
+    canvas.width = width;
+    canvas.height = height;
+    const ctx = canvas.getContext("2d");
+    if (!ctx) return file;
+
+    ctx.drawImage(bitmap, 0, 0, width, height);
+    bitmap.close();
+
+    const blob = await new Promise<Blob | null>((resolve) => {
+      canvas.toBlob((b) => resolve(b), "image/jpeg", JPEG_QUALITY);
+    });
+    if (!blob || blob.size === 0) return file;
+
+    // Prefer compressed only when it actually shrinks the upload.
+    if (blob.size >= file.size * 0.95) return file;
+
+    const base = file.name.replace(/\.[^.]+$/, "") || "evidence";
+    return new File([blob], `${base}.jpg`, {
+      type: "image/jpeg",
+      lastModified: Date.now(),
+    });
+  } catch {
+    try {
+      bitmap.close();
+    } catch {
+      // ignore
+    }
+    return file;
+  }
+}

lib/jobs/kick.ts

@@ -2,16 +2,53 @@ import "server-only";
 
 /**
  * Fire-and-forget drain of pending agent_jobs so user-facing work
- * (verifier / drafter) does not wait solely for the 10-minute Hobby cron.
+ * (verifier / drafter) does not wait solely for the Hobby cron.
  *
- * Safe to call from request handlers, after(), and agent runners:
- * - single-flight (overlapping kicks collapse)
- * - failures are swallowed; durable cron still drains
+ * Two paths:
+ * 1. In-process `processAgentJobs` (same serverless isolate, single-flight)
+ * 2. HTTP POST to `/api/v1/internal/jobs/process` (wakes a fresh worker if
+ *    the in-process path is busy/unavailable — agents stay alive)
  */
 
 let inFlight: Promise<{ processed: number; succeeded: number; failed: number } | null> | null =
   null;
 
+function appBaseUrl(): string | null {
+  const raw =
+    process.env.NEXT_PUBLIC_APP_URL?.trim() ||
+    process.env.VERCEL_PROJECT_PRODUCTION_URL?.trim() ||
+    process.env.VERCEL_URL?.trim() ||
+    "";
+  if (!raw) return null;
+  if (raw.startsWith("http://") || raw.startsWith("https://")) {
+    return raw.replace(/\/$/, "");
+  }
+  return `https://${raw.replace(/\/$/, "")}`;
+}
+
+/** Best-effort wake of the job worker via authenticated internal route. */
+export async function httpKickJobWorker(limit = 8): Promise<boolean> {
+  const base = appBaseUrl();
+  const secret = process.env.CRON_SECRET?.trim();
+  if (!base || !secret) return false;
+
+  try {
+    const res = await fetch(`${base}/api/v1/internal/jobs/process`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${secret}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ limit }),
+      // Do not hang the parent forever if the worker is slow.
+      signal: AbortSignal.timeout(55_000),
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
 export async function kickPendingJobs(limit = 8): Promise<{
   processed: number;
   succeeded: number;
@@ -22,8 +59,16 @@ export async function kickPendingJobs(limit = 8): Promise<{
   inFlight = (async () => {
     try {
       const { processAgentJobs } = await import("@/lib/jobs/process");
-      return await processAgentJobs({ limit });
+      const result = await processAgentJobs({ limit });
+      // If nothing was processed (empty queue race) still ok; if we had work
+      // and more may remain, the HTTP kick below can drain residual.
+      if (result.processed >= limit) {
+        void httpKickJobWorker(limit);
+      }
+      return result;
     } catch {
+      // Isolate may lack DB; try HTTP worker so agents are not "dead".
+      await httpKickJobWorker(limit);
       return null;
     } finally {
       inFlight = null;
@@ -35,11 +80,15 @@ export async function kickPendingJobs(limit = 8): Promise<{
 
 /**
  * Schedule a queue kick after the HTTP response when possible (Next `after`),
- * otherwise run immediately (cron / scripts / tests without request scope).
+ * otherwise run immediately. Always dual-paths: in-process + HTTP wake.
  */
 export function scheduleJobKick(limit = 8): void {
   const run = () => {
-    void kickPendingJobs(limit);
+    void (async () => {
+      await kickPendingJobs(limit);
+      // Second wake in a separate worker so backlog never sits until cron.
+      void httpKickJobWorker(limit);
+    })();
   };
 
   void import("next/server")