stagent 0.3.5 → 0.4.0

package/README.md

@@ -73,6 +73,7 @@ Stagent ships a shared runtime registry that routes tasks, schedules, and workfl
 | 🧪 | **[E2E Test Automation](#e2e-test-automation)** | API-level end-to-end test suite covering both runtimes, 4 profiles, and 4 workflow patterns |
 | ⌨️ | **[Command Palette](#command-palette)** | Global `⌘K` search for fast navigation across tasks, projects, workflows, and settings |
 | 📖 | **[Playbook](#playbook)** | Built-in documentation with usage-stage awareness, adoption heatmap, and guided learning journeys |
+| 📚 | **[Living Book](#living-book)** | AI-native book reader with 9 chapters, agent-powered regeneration, staleness detection, and reading paths |
 
 ---
 
@@ -207,6 +208,16 @@ Built-in documentation system at `/playbook` with usage-stage awareness that ada
 
 <img src="https://raw.githubusercontent.com/navam-io/stagent/main/public/readme/playbook-list.png" alt="Stagent playbook documentation" width="1200" />
 
+#### Living Book
+AI-native book reader at `/book` with 9 chapters across 3 parts (Foundation, Intelligence, Autonomy). Each chapter is generated from Stagent's own source code and feature docs by the document-writer agent — making this a book that writes itself.
+
+- **Chapter regeneration** — one-click regeneration via the document-writer agent profile with fire-and-forget task execution
+- **Staleness detection** — git-based change tracking compares source file timestamps against `lastGeneratedBy` frontmatter to show when chapters need updating
+- **Live progress streaming** — SSE subscription shows real-time agent steps during generation (Reading files → Planning → Composing → Writing) with fade-in animation
+- **Reading paths** — 4 persona-based paths (Getting Started, Team Lead, Power User, Developer) filter chapter navigation
+- **Try It Now** — each chapter links to related Playbook feature docs and user journeys
+- **Author's Notes** — collapsible callout blocks with behind-the-scenes commentary
+
 ### Platform
 
 #### Tool Permission Persistence

package/dist/cli.js

@@ -104,7 +104,9 @@ var STAGENT_TABLES = [
   "environment_sync_ops",
   "environment_templates",
   "conversations",
-  "chat_messages"
+  "chat_messages",
+  "reading_progress",
+  "bookmarks"
 ];
 function bootstrapStagentDatabase(sqlite2) {
   sqlite2.exec(`
@@ -448,6 +450,26 @@ function bootstrapStagentDatabase(sqlite2) {
     CREATE INDEX IF NOT EXISTS idx_chat_messages_conversation_id ON chat_messages(conversation_id);
     CREATE INDEX IF NOT EXISTS idx_chat_messages_conversation_created ON chat_messages(conversation_id, created_at);
   `);
+  sqlite2.exec(`
+    CREATE TABLE IF NOT EXISTS reading_progress (
+      chapter_id TEXT PRIMARY KEY NOT NULL,
+      progress INTEGER DEFAULT 0 NOT NULL,
+      scroll_position INTEGER DEFAULT 0 NOT NULL,
+      last_read_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS bookmarks (
+      id TEXT PRIMARY KEY NOT NULL,
+      chapter_id TEXT NOT NULL,
+      section_id TEXT,
+      scroll_position INTEGER DEFAULT 0 NOT NULL,
+      label TEXT NOT NULL,
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_bookmarks_chapter_id ON bookmarks(chapter_id);
+  `);
 }
 function hasLegacyStagentTables(sqlite2) {
   const placeholders = STAGENT_TABLES.map(() => "?").join(", ");
@@ -496,15 +518,16 @@ function markAllMigrationsApplied(sqlite2, migrationsFolder, migrationsTable = "
 var __dirname = dirname2(fileURLToPath(import.meta.url));
 var appDir = join3(__dirname, "..");
 var launchCwd = process.cwd();
-var DATA_DIR = getStagentDataDir();
-var dbPath = getStagentDbPath();
 var pkg = JSON.parse(readFileSync(join3(appDir, "package.json"), "utf-8"));
-var HELP_TEXT = `
+function getHelpText() {
+  const dir = getStagentDataDir();
+  const db2 = getStagentDbPath();
+  return `
 Data:
-  Directory        ${DATA_DIR}
-  Database         ${dbPath}
-  Sessions         ${join3(DATA_DIR, "sessions")}
-  Logs             ${join3(DATA_DIR, "logs")}
+  Directory        ${dir}
+  Database         ${db2}
+  Sessions         ${join3(dir, "sessions")}
+  Logs             ${join3(dir, "logs")}
 
 Environment variables:
   STAGENT_DATA_DIR Custom data directory for the web app
@@ -513,10 +536,16 @@ Environment variables:
 
 Examples:
   node dist/cli.js --port 3210 --no-open
-  STAGENT_DATA_DIR=/tmp/stagent node dist/cli.js --reset
+  node dist/cli.js --data-dir ~/.stagent-dogfood --port 3100
 `;
-program.name("stagent").description("Governed AI agent workspace").version(pkg.version).addHelpText("after", HELP_TEXT).option("-p, --port <number>", "port to start on", "3000").option("--reset", "delete the local database before starting").option("--no-open", "don't auto-open browser").parse();
+}
+program.name("stagent").description("Governed AI agent workspace").version(pkg.version).addHelpText("after", getHelpText).option("-p, --port <number>", "port to start on", "3000").option("--data-dir <path>", "custom data directory (overrides STAGENT_DATA_DIR)").option("--reset", "delete the local database before starting").option("--no-open", "don't auto-open browser").parse();
 var opts = program.opts();
+if (opts.dataDir) {
+  process.env.STAGENT_DATA_DIR = opts.dataDir;
+}
+var DATA_DIR = getStagentDataDir();
+var dbPath = getStagentDbPath();
 var requestedPort = Number.parseInt(opts.port, 10);
 if (Number.isNaN(requestedPort) || requestedPort <= 0) {
   program.error(`Invalid port: ${opts.port}`);

package/drizzle.config.ts

@@ -2,11 +2,13 @@ import { defineConfig } from "drizzle-kit";
 import { homedir } from "os";
 import { join } from "path";
 
+const dataDir = process.env.STAGENT_DATA_DIR || join(homedir(), ".stagent");
+
 export default defineConfig({
   schema: "./src/lib/db/schema.ts",
   out: "./src/lib/db/migrations",
   dialect: "sqlite",
   dbCredentials: {
-    url: join(homedir(), ".stagent", "stagent.db"),
+    url: join(dataDir, "stagent.db"),
   },
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stagent",
-  "version": "0.3.5",
+  "version": "0.4.0",
   "description": "Governed AI agent workspace for supervised local execution, workflows, documents, and provider runtimes.",
   "keywords": [
     "ai",
@@ -50,6 +50,7 @@
     "test:e2e": "vitest run --config vitest.config.e2e.ts",
     "test:ui": "vitest --ui",
     "validate:tokens": "npx tsx design-system/validate-tokens.ts",
+    "sync-worktree": "bash bin/sync-worktree.sh",
     "prepublishOnly": "npm run build:cli"
   },
   "engines": {
@@ -88,6 +89,7 @@
     "remark-gfm": "^4.0.1",
     "smol-toml": "^1.6.0",
     "sonner": "^2.0.7",
+    "sugar-high": "^1.0.0",
     "tailwind-merge": "^3",
     "tailwindcss": "^4",
     "tw-animate-css": "^1",

package/src/app/api/book/bookmarks/route.ts

@@ -0,0 +1,73 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db } from "@/lib/db";
+import { bookmarks } from "@/lib/db/schema";
+import { eq } from "drizzle-orm";
+import { randomUUID } from "crypto";
+
+/** GET /api/book/bookmarks — return all bookmarks */
+export async function GET() {
+  const rows = db.select().from(bookmarks).all();
+  return NextResponse.json(
+    rows.map((r) => ({
+      id: r.id,
+      chapterId: r.chapterId,
+      sectionId: r.sectionId,
+      scrollPosition: r.scrollPosition,
+      label: r.label,
+      createdAt: r.createdAt.toISOString(),
+    }))
+  );
+}
+
+/** POST /api/book/bookmarks — create a bookmark */
+export async function POST(req: NextRequest) {
+  const body = await req.json();
+  const { chapterId, sectionId, scrollPosition, label } = body as {
+    chapterId: string;
+    sectionId?: string;
+    scrollPosition: number;
+    label: string;
+  };
+
+  if (!chapterId || !label) {
+    return NextResponse.json({ error: "chapterId and label required" }, { status: 400 });
+  }
+
+  const id = randomUUID();
+  const now = new Date();
+
+  db.insert(bookmarks)
+    .values({
+      id,
+      chapterId,
+      sectionId: sectionId ?? null,
+      scrollPosition: scrollPosition ?? 0,
+      label,
+      createdAt: now,
+    })
+    .run();
+
+  return NextResponse.json({
+    id,
+    chapterId,
+    sectionId: sectionId ?? null,
+    scrollPosition: scrollPosition ?? 0,
+    label,
+    createdAt: now.toISOString(),
+  }, { status: 201 });
+}
+
+/** DELETE /api/book/bookmarks?id=xxx — delete a bookmark */
+export async function DELETE(req: NextRequest) {
+  const id = req.nextUrl.searchParams.get("id");
+  if (!id) {
+    return NextResponse.json({ error: "id required" }, { status: 400 });
+  }
+
+  const result = db.delete(bookmarks).where(eq(bookmarks.id, id)).run();
+  if (result.changes === 0) {
+    return NextResponse.json({ error: "not found" }, { status: 404 });
+  }
+
+  return NextResponse.json({ ok: true });
+}

package/src/app/api/book/progress/route.ts

@@ -0,0 +1,79 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db } from "@/lib/db";
+import { readingProgress } from "@/lib/db/schema";
+import { eq } from "drizzle-orm";
+
+/** GET /api/book/progress — return all chapter progress */
+export async function GET() {
+  const rows = db.select().from(readingProgress).all();
+  // Return as a map: chapterId → { progress, scrollPosition, lastReadAt }
+  const result: Record<string, { progress: number; scrollPosition: number; lastReadAt: string }> = {};
+  for (const row of rows) {
+    result[row.chapterId] = {
+      // progress is stored as integer 0–1000 for precision in SQLite
+      progress: row.progress / 1000,
+      scrollPosition: row.scrollPosition,
+      lastReadAt: row.lastReadAt.toISOString(),
+    };
+  }
+  return NextResponse.json(result);
+}
+
+/** PUT /api/book/progress — upsert progress for a chapter */
+export async function PUT(req: NextRequest) {
+  const body = await req.json();
+  const { chapterId, progress: pct, scrollPosition } = body as {
+    chapterId: string;
+    progress: number;
+    scrollPosition: number;
+  };
+
+  if (!chapterId || typeof pct !== "number") {
+    return NextResponse.json({ error: "chapterId and progress required" }, { status: 400 });
+  }
+
+  const now = new Date();
+  // Store progress as integer 0–1000
+  const progressInt = Math.round(Math.min(1, Math.max(0, pct)) * 1000);
+
+  // Check existing to enforce high-water mark
+  const existing = db
+    .select()
+    .from(readingProgress)
+    .where(eq(readingProgress.chapterId, chapterId))
+    .get();
+
+  if (existing && existing.progress >= progressInt) {
+    // Only update scroll position and timestamp, don't decrease progress
+    db.update(readingProgress)
+      .set({
+        scrollPosition: scrollPosition ?? existing.scrollPosition,
+        lastReadAt: now,
+        updatedAt: now,
+      })
+      .where(eq(readingProgress.chapterId, chapterId))
+      .run();
+  } else if (existing) {
+    db.update(readingProgress)
+      .set({
+        progress: progressInt,
+        scrollPosition: scrollPosition ?? 0,
+        lastReadAt: now,
+        updatedAt: now,
+      })
+      .where(eq(readingProgress.chapterId, chapterId))
+      .run();
+  } else {
+    db.insert(readingProgress)
+      .values({
+        chapterId,
+        progress: progressInt,
+        scrollPosition: scrollPosition ?? 0,
+        lastReadAt: now,
+        updatedAt: now,
+      })
+      .run();
+  }
+
+  return NextResponse.json({ ok: true });
+}

package/src/app/api/book/regenerate/route.ts

@@ -0,0 +1,111 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db } from "@/lib/db";
+import { tasks } from "@/lib/db/schema";
+import { getChapter } from "@/lib/book/content";
+import { getChapterStaleness, detectStaleChapters } from "@/lib/book/update-detector";
+import { buildChapterRegenerationPrompt } from "@/lib/book/chapter-generator";
+import { executeTaskWithAgent } from "@/lib/agents/router";
+
+export const dynamic = "force-dynamic";
+
+/**
+ * POST /api/book/regenerate
+ * Create a task to generate/regenerate a book chapter using the document-writer agent.
+ */
+export async function POST(request: Request) {
+  try {
+    const body = await request.json();
+    const { chapterId } = body;
+
+    if (!chapterId || typeof chapterId !== "string") {
+      return NextResponse.json(
+        { error: "chapterId is required" },
+        { status: 400 }
+      );
+    }
+
+    const chapter = getChapter(chapterId);
+    if (!chapter) {
+      return NextResponse.json(
+        { error: `Chapter not found: ${chapterId}` },
+        { status: 404 }
+      );
+    }
+
+    // Check staleness
+    const staleness = getChapterStaleness(chapterId);
+
+    // Build the regeneration prompt
+    const prompt = buildChapterRegenerationPrompt(chapterId);
+
+    const isNew = chapter.sections.length === 0;
+    const verb = isNew ? "Generate" : "Regenerate";
+
+    // Create a real task with the document-writer profile
+    const taskId = crypto.randomUUID();
+    const now = new Date();
+
+    await db.insert(tasks).values({
+      id: taskId,
+      title: `${verb} Chapter ${chapter.number}: ${chapter.title}`,
+      description: prompt,
+      agentProfile: "document-writer",
+      assignedAgent: "claude-code",
+      status: "queued",
+      priority: 1,
+      createdAt: now,
+      updatedAt: now,
+    });
+
+    // Fire-and-forget execution
+    executeTaskWithAgent(taskId, "claude-code");
+
+    return NextResponse.json(
+      {
+        taskId,
+        chapterId,
+        chapterTitle: chapter.title,
+        chapterNumber: chapter.number,
+        isNew,
+        staleness,
+      },
+      { status: 202 }
+    );
+  } catch (error) {
+    console.error("Regenerate error:", error);
+    return NextResponse.json(
+      { error: "Failed to start chapter generation" },
+      { status: 500 }
+    );
+  }
+}
+
+/**
+ * GET /api/book/regenerate
+ * Check staleness. Supports ?chapterId=X for a single chapter.
+ */
+export async function GET(request: NextRequest) {
+  try {
+    const chapterId = request.nextUrl.searchParams.get("chapterId");
+
+    if (chapterId) {
+      const staleness = getChapterStaleness(chapterId);
+      if (!staleness) {
+        return NextResponse.json(
+          { error: `Chapter not found: ${chapterId}` },
+          { status: 404 }
+        );
+      }
+      return NextResponse.json(staleness);
+    }
+
+    const staleness = detectStaleChapters();
+    return NextResponse.json({ chapters: staleness });
+  } catch (error) {
+    console.error("Staleness check error:", error);
+    return NextResponse.json(
+      { error: "Failed to check staleness" },
+      { status: 500 }
+    );
+  }
+}

package/src/app/api/book/stage/route.ts

@@ -0,0 +1,13 @@
+import { NextResponse } from "next/server";
+import { getUsageStage } from "@/lib/docs/usage-stage";
+import { recommendPath } from "@/lib/book/reading-paths";
+
+export const dynamic = "force-dynamic";
+
+export async function GET() {
+  const stage = await getUsageStage();
+  return NextResponse.json({
+    stage,
+    recommendedPath: recommendPath(stage),
+  });
+}

package/src/app/api/chat/conversations/[id]/respond/route.ts

@@ -40,25 +40,23 @@ export async function POST(
     );
   }
 
-  if (!hasPendingRequest(requestId)) {
-    return NextResponse.json(
-      { error: "No pending request found (may have timed out)" },
-      { status: 404 }
-    );
-  }
-
-  // Resolve the in-memory Promise — this unblocks the SDK
-  const resolved = resolvePendingRequest(requestId, {
-    behavior,
-    updatedInput: behavior === "allow" ? updatedInput : undefined,
-    message: behavior === "deny" ? (message ?? "User denied this action") : undefined,
-  });
+  // Resolve the in-memory Promise if it still exists (unblocks SDK).
+  // The request may already be gone (timeout, HMR restart, connection drop)
+  // — that's fine, we still update DB and UI below.
+  const isPending = hasPendingRequest(requestId);
+  if (isPending) {
+    const resolved = resolvePendingRequest(requestId, {
+      behavior,
+      updatedInput: behavior === "allow" ? updatedInput : undefined,
+      message: behavior === "deny" ? (message ?? "User denied this action") : undefined,
+    });
 
-  if (!resolved) {
-    return NextResponse.json(
-      { error: "Failed to resolve request" },
-      { status: 500 }
-    );
+    if (!resolved) {
+      return NextResponse.json(
+        { error: "Failed to resolve request" },
+        { status: 500 }
+      );
+    }
   }
 
   // If "Always Allow" was selected, persist the permission pattern
@@ -71,10 +69,11 @@ export async function POST(
     }
   }
 
-  // Update the system message status to reflect the response
+  // Always update the system message status — even for stale requests
+  // so the UI reflects the user's action on reload
   if (messageId) {
     await updateMessageStatus(messageId, behavior === "allow" ? "complete" : "error");
   }
 
-  return NextResponse.json({ ok: true });
+  return NextResponse.json({ ok: true, stale: !isPending });
 }

package/src/app/api/chat/conversations/[id]/route.ts

@@ -42,7 +42,7 @@ export async function PATCH(
 ) {
   const { id } = await params;
   const body = await req.json();
-  const { title, status, modelId } = body;
+  const { title, status, modelId, runtimeId } = body;
 
   const existing = await getConversation(id);
   if (!existing) {
@@ -64,6 +64,7 @@ export async function PATCH(
     updates.status = status;
   }
   if (modelId !== undefined) updates.modelId = modelId;
+  if (runtimeId !== undefined) updates.runtimeId = runtimeId;
 
   const updated = await updateConversation(id, updates);
   return NextResponse.json(updated);

package/src/app/api/documents/[id]/route.ts

@@ -5,10 +5,14 @@ import { eq } from "drizzle-orm";
 import { unlink } from "fs/promises";
 import { z } from "zod/v4";
 
+import { processDocument } from "@/lib/documents/processor";
+
 const documentPatchSchema = z.object({
   taskId: z.string().uuid().nullable().optional(),
   projectId: z.string().uuid().nullable().optional(),
   category: z.string().max(100).optional(),
+  metadata: z.record(z.string(), z.string()).optional(),
+  reprocess: z.boolean().optional(),
 });
 
 export async function GET(
@@ -81,13 +85,31 @@ export async function PATCH(
 
   if ("taskId" in body) updates.taskId = body.taskId;
   if ("projectId" in body) updates.projectId = body.projectId;
-  if ("category" in body) updates.category = body.category;
+  if ("category" in body && typeof body.category === "string") updates.category = body.category;
+
+  // Merge metadata into category field (JSON)
+  if (body.metadata) {
+    const existing = doc.category ? (() => { try { return JSON.parse(doc.category); } catch { return {}; } })() : {};
+    updates.category = JSON.stringify({ ...existing, ...body.metadata });
+  }
+
+  // Reprocess: clear extracted fields and re-run
+  if (body.reprocess) {
+    updates.extractedText = null;
+    updates.processedPath = null;
+    updates.processingError = null;
+    updates.status = "processing";
+  }
 
   await db
     .update(documents)
     .set(updates)
     .where(eq(documents.id, id));
 
+  if (body.reprocess) {
+    processDocument(id).catch(() => {});
+  }
+
   const [updated] = await db
     .select()
     .from(documents)
@@ -97,10 +119,12 @@ export async function PATCH(
 }
 
 export async function DELETE(
-  _req: NextRequest,
+  req: NextRequest,
   { params }: { params: Promise<{ id: string }> }
 ) {
   const { id } = await params;
+  const url = new URL(req.url);
+  const cascadeDelete = url.searchParams.get("cascadeDelete") === "true";
 
   const [doc] = await db
     .select()
@@ -111,6 +135,14 @@ export async function DELETE(
     return NextResponse.json({ error: "Document not found" }, { status: 404 });
   }
 
+  // Cascade safety: if linked to a task and cascadeDelete not set, reject
+  if (doc.taskId && !cascadeDelete) {
+    return NextResponse.json(
+      { error: `Document is linked to task ${doc.taskId}. Add ?cascadeDelete=true to confirm.` },
+      { status: 409 }
+    );
+  }
+
   try {
     await unlink(doc.storagePath);
   } catch {

package/src/app/api/documents/route.ts

@@ -2,6 +2,12 @@ import { NextRequest, NextResponse } from "next/server";
 import { db } from "@/lib/db";
 import { documents, tasks, projects } from "@/lib/db/schema";
 import { eq, and, like, or, desc, sql } from "drizzle-orm";
+import { access, stat, copyFile, mkdir } from "fs/promises";
+import { basename, extname, join } from "path";
+import crypto from "crypto";
+import { getStagentUploadsDir } from "@/lib/utils/stagent-paths";
+import { processDocument } from "@/lib/documents/processor";
+import { z } from "zod/v4";
 
 const VALID_DOC_STATUSES = ["uploaded", "processing", "ready", "error"] as const;
 const VALID_DOC_DIRECTIONS = ["input", "output"] as const;
@@ -76,3 +82,88 @@ export async function GET(req: NextRequest) {
 
   return NextResponse.json(result);
 }
+
+const MIME_TYPES: Record<string, string> = {
+  ".md": "text/markdown",
+  ".txt": "text/plain",
+  ".json": "application/json",
+  ".csv": "text/csv",
+  ".html": "text/html",
+  ".pdf": "application/pdf",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+};
+
+const uploadSchema = z.object({
+  file_path: z.string().min(1),
+  taskId: z.string().optional(),
+  projectId: z.string().optional(),
+  direction: z.enum(["input", "output"]).optional().default("output"),
+  metadata: z.record(z.string(), z.string()).optional(),
+});
+
+export async function POST(req: NextRequest) {
+  const raw = await req.json();
+  const parsed = uploadSchema.safeParse(raw);
+
+  if (!parsed.success) {
+    return NextResponse.json(
+      { error: "Invalid request body", details: parsed.error.issues },
+      { status: 400 }
+    );
+  }
+
+  const body = parsed.data;
+
+  try {
+    await access(body.file_path);
+  } catch {
+    return NextResponse.json({ error: `File not found: ${body.file_path}` }, { status: 400 });
+  }
+
+  const stats = await stat(body.file_path);
+  if (!stats.isFile()) {
+    return NextResponse.json({ error: `Not a file: ${body.file_path}` }, { status: 400 });
+  }
+
+  const originalName = basename(body.file_path);
+  const ext = extname(originalName).toLowerCase();
+  const mimeType = MIME_TYPES[ext] ?? "application/octet-stream";
+  const id = crypto.randomUUID();
+  const filename = `${id}${ext}`;
+
+  const uploadsDir = getStagentUploadsDir();
+  await mkdir(uploadsDir, { recursive: true });
+  const storagePath = join(uploadsDir, filename);
+  await copyFile(body.file_path, storagePath);
+
+  const now = new Date();
+  await db.insert(documents).values({
+    id,
+    taskId: body.taskId ?? null,
+    projectId: body.projectId ?? null,
+    filename,
+    originalName,
+    mimeType,
+    size: stats.size,
+    storagePath,
+    version: 1,
+    direction: body.direction,
+    status: "uploaded",
+    createdAt: now,
+    updatedAt: now,
+  });
+
+  // Fire-and-forget preprocessing
+  processDocument(id).catch(() => {});
+
+  return NextResponse.json(
+    { documentId: id, status: "uploaded", processingStatus: "queued", originalName, mimeType, size: stats.size },
+    { status: 201 }
+  );
+}