@prismshadow/penguin-server 0.1.4 → 0.1.5

package/dist/index.js

@@ -3,10 +3,11 @@ import { config as loadDotenv } from "dotenv";
 import { serve } from "@hono/node-server";
 
 // src/app.ts
-import fs16 from "fs";
+import fs17 from "fs";
 import fsp from "fs/promises";
-import path15 from "path";
+import path16 from "path";
 import { Hono as Hono21 } from "hono";
+import { bodyLimit } from "hono/body-limit";
 
 // src/db/database.ts
 import { mkdirSync } from "fs";
@@ -299,13 +300,13 @@ var ErrorsRepo = class {
     };
   }
   /** The most recent `limit` entries (reverse chronological order). */
-  recent(projectId, f = {}, limit = 20) {
+  recent(projectId, f = {}, limit = 20, offset = 0) {
     const { where, params } = this.conds(projectId, f);
     const rows = this.db.prepare(
       `SELECT ts, source, code, kind, message
          FROM error_records WHERE ${where}
-         ORDER BY id DESC LIMIT :limit`
-    ).all({ ...params, limit });
+         ORDER BY id DESC LIMIT :limit OFFSET :offset`
+    ).all({ ...params, limit, offset });
     return rows.map((r) => ({
       ts: r.ts,
       source: r.source,
@@ -1563,6 +1564,14 @@ function projectsRoutes(deps2) {
     const project = await deps2.projectService.createProject(c.var.user, projectId, name);
     return c.json({ project }, 201);
   });
+  app2.patch("/:projectId", async (c) => {
+    const projectId = requireValidId(c, "projectId");
+    const body = await readJson(c);
+    const name = requireString(body, "name", { maxLen: 100, label: "name" }).trim();
+    if (name === "") throw badRequest("name must be at least 1 characters.");
+    const project = await deps2.projectService.renameProject(c.var.user.userId, projectId, name);
+    return c.json({ project });
+  });
   app2.delete("/:projectId", async (c) => {
     await deps2.projectService.deleteProject(c.var.user.userId, requireValidId(c, "projectId"));
     return c.body(null, 204);
@@ -2190,6 +2199,7 @@ async function readItem(deps2, projectId, agentId, name) {
 
 // src/http/routes/benchmarks.ts
 import { Hono as Hono10 } from "hono";
+var TEXT_PREVIEW_BYTES = 256 * 1024;
 function benchmarksRoutes(deps2) {
   const app2 = new Hono10();
   app2.get("/", async (c) => {
@@ -2199,6 +2209,58 @@ function benchmarksRoutes(deps2) {
     await deps2.agentConfigService.requireExists(projectId, agentId);
     return c.json(await deps2.benchmarks.list(projectId, agentId));
   });
+  app2.get("/:benchmarkId/cases", async (c) => {
+    const projectId = requireValidId(c, "projectId");
+    const agentId = requireValidId(c, "agentId");
+    const benchmarkId = requireValidId(c, "benchmarkId");
+    deps2.projectService.requireProjectAccess(c.var.user.userId, projectId);
+    await deps2.agentConfigService.requireExists(projectId, agentId);
+    return c.json(await deps2.benchmarks.listCases(projectId, agentId, benchmarkId));
+  });
+  app2.get("/:benchmarkId/cases/:caseId/files", async (c) => {
+    const projectId = requireValidId(c, "projectId");
+    const agentId = requireValidId(c, "agentId");
+    const benchmarkId = requireValidId(c, "benchmarkId");
+    const caseId = requireValidId(c, "caseId");
+    deps2.projectService.requireProjectAccess(c.var.user.userId, projectId);
+    await deps2.agentConfigService.requireExists(projectId, agentId);
+    return c.json(
+      await deps2.benchmarks.listCaseFiles(
+        projectId,
+        agentId,
+        benchmarkId,
+        caseId,
+        c.req.query("path") ?? ""
+      )
+    );
+  });
+  app2.get("/:benchmarkId/cases/:caseId/files/content", async (c) => {
+    const projectId = requireValidId(c, "projectId");
+    const agentId = requireValidId(c, "agentId");
+    const benchmarkId = requireValidId(c, "benchmarkId");
+    const caseId = requireValidId(c, "caseId");
+    deps2.projectService.requireProjectAccess(c.var.user.userId, projectId);
+    await deps2.agentConfigService.requireExists(projectId, agentId);
+    const download = c.req.query("download") === "1";
+    const boundedPreview = !download && c.req.query("preview") === "1";
+    const { data, fileName, contentType, scriptable, truncated } = await deps2.benchmarks.readCaseFile(
+      projectId,
+      agentId,
+      benchmarkId,
+      caseId,
+      c.req.query("path") ?? "",
+      boundedPreview ? { maxBytes: TEXT_PREVIEW_BYTES } : void 0
+    );
+    return new Response(new Uint8Array(data), {
+      status: 200,
+      headers: {
+        "Content-Type": !download && scriptable ? "text/plain; charset=utf-8" : contentType,
+        "Content-Disposition": `${download ? "attachment" : "inline"}; filename*=UTF-8''${encodeURIComponent(fileName)}`,
+        "X-Content-Type-Options": "nosniff",
+        ...truncated ? { "X-Content-Truncated": "1" } : {}
+      }
+    });
+  });
   return app2;
 }
 
@@ -2611,12 +2673,32 @@ function usageRoutes(deps2) {
       })
     );
   });
+  app2.get("/errors", (c) => {
+    const projectId = requireValidId(c, "projectId");
+    deps2.projectService.requireProjectAccess(c.var.user.userId, projectId);
+    const { offset, limit } = paginationQuery(c);
+    const from = optionalDateParam(c.req.query("from"), "from");
+    const to = optionalDateParam(c.req.query("to"), "to");
+    const agentId = c.req.query("agentId");
+    return c.json(
+      deps2.usageService.queryErrors(projectId, {
+        offset,
+        limit,
+        // Same admin-only rule as the dashboard: a regular member seeing another tenant's
+        // unattributed errors would be a cross-tenant leak.
+        includeGlobalErrors: c.var.user.isAdmin,
+        ...from !== void 0 ? { from } : {},
+        ...to !== void 0 ? { to } : {},
+        ...agentId !== void 0 && agentId !== "" ? { agentId } : {}
+      })
+    );
+  });
   return app2;
 }
 
 // src/http/routes/sessions.ts
-import fs7 from "fs/promises";
-import path6 from "path";
+import fs8 from "fs/promises";
+import path7 from "path";
 import { Hono as Hono18 } from "hono";
 import { imageUrlMessage, scratchpadDir, userText } from "@prismshadow/penguin-core";
 
@@ -2796,9 +2878,14 @@ var WorkspaceFilesService = class {
     );
     return unique.filter((_, i) => exists[i]);
   }
-  /** List a directory: dirs come first, each group sorted by name; kind follows the symlink target (consistent with read behavior). */
+  /**
+   * List a directory: dirs come first, each group sorted by name. Entries whose
+   * canonical target leaves the Workspace are omitted, so listing cannot expose
+   * metadata for an out-of-bounds symlink.
+   */
   async list(workspace, rel) {
     const dir = await this.resolveRead(workspace, rel);
+    const realBase = await this.realBase(workspace);
     let dirents;
     try {
       dirents = await fs6.readdir(dir, { withFileTypes: true });
@@ -2811,33 +2898,31 @@ var WorkspaceFilesService = class {
       }
       throw err;
     }
-    const entries = await Promise.all(
+    const listed = await Promise.all(
       dirents.map(async (d) => {
-        let sizeBytes = 0;
-        let mtime = "";
-        let isDir = d.isDirectory();
         try {
-          const stat = await fs6.stat(path5.join(dir, d.name));
-          sizeBytes = stat.size;
-          mtime = stat.mtime.toISOString();
-          isDir = stat.isDirectory();
+          const canonical = await fs6.realpath(path5.join(dir, d.name));
+          this.assertInside(canonical, realBase);
+          const stat = await fs6.stat(canonical);
+          return {
+            name: d.name,
+            kind: stat.isDirectory() ? "dir" : "file",
+            sizeBytes: stat.size,
+            mtime: stat.mtime.toISOString()
+          };
         } catch {
+          return null;
         }
-        return {
-          name: d.name,
-          kind: isDir ? "dir" : "file",
-          sizeBytes,
-          mtime
-        };
       })
     );
+    const entries = listed.filter((entry) => entry !== null);
     entries.sort(
       (a, b) => a.kind === b.kind ? a.name.localeCompare(b.name) : a.kind === "dir" ? -1 : 1
     );
     return { path: rel, entries };
   }
   /** Read a file (preview/download): IO on the canonical path (resolveRead has already eliminated symlink escapes). */
-  async read(workspace, rel) {
+  async read(workspace, rel, options) {
     const file = await this.resolveRead(workspace, rel);
     let stat;
     try {
@@ -2846,16 +2931,35 @@ var WorkspaceFilesService = class {
       throw new HttpError(404, "path_not_found", "File does not exist.");
     }
     if (stat.isDirectory()) throw badRequest("path is a directory.");
-    if (stat.size > MAX_READ_BYTES) {
+    const maxBytes = options?.maxBytes;
+    if (maxBytes !== void 0 && (!Number.isSafeInteger(maxBytes) || maxBytes < 1 || maxBytes > MAX_READ_BYTES)) {
+      throw badRequest("maxBytes must be a positive integer within the read limit.");
+    }
+    if (maxBytes === void 0 && stat.size > MAX_READ_BYTES) {
       throw new HttpError(413, "file_too_large", "File exceeds the 50MB read limit.");
     }
-    const data = await fs6.readFile(file);
+    let data;
+    let truncated = false;
+    if (maxBytes !== void 0 && stat.size > maxBytes) {
+      const handle = await fs6.open(file, "r");
+      try {
+        const buffer = Buffer.alloc(maxBytes);
+        const { bytesRead } = await handle.read(buffer, 0, maxBytes, 0);
+        data = buffer.subarray(0, bytesRead);
+        truncated = true;
+      } finally {
+        await handle.close();
+      }
+    } else {
+      data = await fs6.readFile(file);
+    }
     const ext = path5.extname(file).toLowerCase();
     return {
       data,
       fileName: path5.basename(file),
       contentType: CONTENT_TYPES[ext] ?? "application/octet-stream",
-      scriptable: ext === ".html" || ext === ".htm" || ext === ".svg"
+      scriptable: ext === ".html" || ext === ".htm" || ext === ".svg",
+      ...truncated ? { truncated: true } : {}
     };
   }
   /**
@@ -2897,6 +3001,133 @@ var WorkspaceFilesService = class {
   }
 };
 
+// src/services/task-attachments.ts
+import fs7 from "fs/promises";
+import path6 from "path";
+import { randomBytes as randomBytes4 } from "crypto";
+import { appendAttachmentLines, attachedFileLine } from "@prismshadow/penguin-core";
+var MAX_ATTACHMENT_BYTES = 10 * 1024 * 1024;
+var MAX_ATTACHMENT_COUNT = 20;
+var MAX_TOTAL_ATTACHMENT_BYTES = 12 * 1024 * 1024;
+var MAX_STEM_BYTES = 80;
+var WINDOWS_RESERVED = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])$/i;
+var INVISIBLE_CHAR = new RegExp("\\p{C}", "u");
+function unsafeNameChar(ch) {
+  if (/[A-Za-z0-9._-]/.test(ch)) return false;
+  return ch.codePointAt(0) < 128 || INVISIBLE_CHAR.test(ch);
+}
+function sanitizeSegment(value) {
+  return Array.from(value, (ch) => unsafeNameChar(ch) ? "-" : ch).join("");
+}
+function truncateBytes(value, maxBytes) {
+  if (Buffer.byteLength(value) <= maxBytes) return value;
+  let out = "";
+  for (const ch of value) {
+    if (Buffer.byteLength(out) + Buffer.byteLength(ch) > maxBytes) break;
+    out += ch;
+  }
+  return out;
+}
+var MAX_NAME_ATTEMPTS = 16;
+function parseAttachmentPart(part, index) {
+  const fileName = part.fileName;
+  if (typeof fileName !== "string" || fileName.length === 0 || fileName.includes("/") || fileName.includes("\\") || fileName.includes("..") || fileName.includes("\0")) {
+    throw badRequest(
+      `input[${index}].fileName must be a non-empty file name without path separators or "..".`
+    );
+  }
+  const dataUrl = part.dataUrl;
+  const match = typeof dataUrl === "string" ? /^data:[^,]*;base64,([A-Za-z0-9+/=\s]+)$/.exec(dataUrl) : null;
+  if (!match) {
+    throw badRequest(`input[${index}].dataUrl must be a base64 data: URL of the file's bytes.`);
+  }
+  const bytes = Buffer.from(match[1], "base64");
+  if (bytes.length === 0) {
+    throw badRequest(`input[${index}].dataUrl decodes to an empty file.`);
+  }
+  if (bytes.length > MAX_ATTACHMENT_BYTES) {
+    throw new HttpError(
+      413,
+      "file_too_large",
+      `Attached file exceeds the ${MAX_ATTACHMENT_BYTES / (1024 * 1024)}MB limit.`
+    );
+  }
+  return { fileName, bytes };
+}
+function assertAttachmentBudget(attachments) {
+  if (attachments.length > MAX_ATTACHMENT_COUNT) {
+    throw new HttpError(
+      413,
+      "too_many_files",
+      `A message may carry at most ${MAX_ATTACHMENT_COUNT} attached files.`
+    );
+  }
+  let total = 0;
+  for (const a of attachments) total += a.bytes.length;
+  if (total > MAX_TOTAL_ATTACHMENT_BYTES) {
+    throw new HttpError(
+      413,
+      "payload_too_large",
+      `Attached files exceed the ${MAX_TOTAL_ATTACHMENT_BYTES / (1024 * 1024)}MB total limit for one message.`
+    );
+  }
+}
+function scratchpadName(fileName) {
+  const ext = sanitizeSegment(path6.extname(fileName));
+  const rawStem = fileName.slice(0, fileName.length - path6.extname(fileName).length);
+  const stem = truncateBytes(sanitizeSegment(rawStem), MAX_STEM_BYTES).replace(/[. ]+$/, "");
+  if (!stem || /^-+$/.test(stem)) return `file${ext}`;
+  return WINDOWS_RESERVED.test(stem) ? `_${stem}${ext}` : `${stem}${ext}`;
+}
+async function writeAttachment(dir, attachment) {
+  const base = scratchpadName(attachment.fileName);
+  const ext = path6.extname(base);
+  const stem = base.slice(0, base.length - ext.length);
+  for (let attempt = 0; attempt < MAX_NAME_ATTEMPTS; attempt++) {
+    const name = attempt === 0 ? base : `${stem}-${randomBytes4(3).toString("hex")}${ext}`;
+    const file = path6.join(dir, name);
+    try {
+      await fs7.writeFile(file, attachment.bytes, { flag: "wx" });
+      return file;
+    } catch (err) {
+      if (err.code !== "EEXIST") throw err;
+    }
+  }
+  throw new Error(
+    `failed to allocate a unique attachment file name under ${dir} after ${MAX_NAME_ATTEMPTS} attempts`
+  );
+}
+async function openScratchpadDir(root, sessionId) {
+  const dir = path6.join(root, sessionId);
+  await fs7.mkdir(dir, { recursive: true });
+  const canonicalRoot = await fs7.realpath(root);
+  const rel = path6.relative(canonicalRoot, await fs7.realpath(dir));
+  if (rel !== sessionId) {
+    throw new Error(
+      `session scratchpad ${dir} resolves outside the agent scratchpad root; refusing to write attachments`
+    );
+  }
+  return dir;
+}
+async function removeAttachments(files) {
+  await Promise.all(files.map((f) => fs7.rm(f, { force: true }).catch(() => {
+  })));
+}
+async function attachFilesToInput(messages, attachments, root, sessionId) {
+  if (attachments.length === 0) return { input: messages, written: [] };
+  const dir = await openScratchpadDir(root, sessionId);
+  const written = [];
+  try {
+    for (const attachment of attachments) {
+      written.push(await writeAttachment(dir, attachment));
+    }
+  } catch (err) {
+    await removeAttachments(written);
+    throw err;
+  }
+  return { input: appendAttachmentLines(messages, written.map(attachedFileLine)), written };
+}
+
 // src/http/routes/sessions.ts
 var SESSION_TITLE_MAX = 120;
 var STAT_MAX_PATHS = 100;
@@ -2914,12 +3145,33 @@ var SESSION_CATEGORIES = [
   "schedule",
   "archived"
 ];
+var IMAGE_DATA_URL = /^data:[^;,]+;base64,[A-Za-z0-9+/=\s]+$/;
+function requireImageUrl(url, field) {
+  if (typeof url === "string") {
+    if (url.startsWith("http://") || url.startsWith("https://")) return url;
+    if (IMAGE_DATA_URL.test(url)) return url;
+  }
+  throw badRequest(
+    `${field} must be an http(s) URL or a base64 data: URL (data:<mime>;base64,<bytes>).`
+  );
+}
+function resolveScratchpadFile(dir, fileName) {
+  if (!fileName || fileName === "." || fileName === "..") return null;
+  for (const ch of fileName) {
+    const code = ch.codePointAt(0);
+    if (code < 32 || code === 127 || ch === "/" || ch === "\\") return null;
+  }
+  const resolved = path7.resolve(dir, fileName);
+  return path7.dirname(resolved) === path7.resolve(dir) ? resolved : null;
+}
 function parseTaskInput(body) {
   const input = body.input;
   if (!Array.isArray(input) || input.length === 0) {
     throw badRequest("input must be an array with at least one item.");
   }
-  return input.map((item, i) => {
+  const messages = [];
+  const attachments = [];
+  input.forEach((item, i) => {
     if (item === null || typeof item !== "object" || Array.isArray(item)) {
       throw badRequest(`input[${i}] must be an object.`);
     }
@@ -2928,17 +3180,27 @@ function parseTaskInput(body) {
       if (typeof part.text !== "string" || part.text.length === 0) {
         throw badRequest(`input[${i}].text must be a non-empty string.`);
       }
-      return userText(part.text);
+      messages.push(userText(part.text));
+      return;
     }
     if (part.type === "image_url") {
-      const url = part.imageUrl;
-      if (typeof url !== "string" || !(url.startsWith("data:") || url.startsWith("http://") || url.startsWith("https://"))) {
-        throw badRequest(`input[${i}].imageUrl only supports data: or http(s) URLs.`);
-      }
-      return imageUrlMessage(url);
+      messages.push(imageUrlMessage(requireImageUrl(part.imageUrl, `input[${i}].imageUrl`)));
+      return;
     }
-    throw badRequest(`input[${i}].type must be one of text / image_url.`);
+    if (part.type === "file") {
+      attachments.push(parseAttachmentPart(part, i));
+      assertAttachmentBudget(attachments);
+      return;
+    }
+    throw badRequest(`input[${i}].type must be one of text / image_url / file.`);
   });
+  return { messages, attachments };
+}
+function parseSteerImages(body) {
+  const images = body.images;
+  if (images === void 0) return [];
+  if (!Array.isArray(images)) throw badRequest("images must be an array.");
+  return images.map((url, i) => requireImageUrl(url, `images[${i}]`));
 }
 function parseGoalField(body) {
   const goal = body.goal;
@@ -3101,8 +3363,8 @@ function sessionsRoutes(deps2) {
         ]);
       }
       await deps2.traceService.deleteSessionTraces(row.projectId, row.agentId, row.sessionId);
-      await fs7.rm(
-        path6.join(scratchpadDir(deps2.config.root, row.projectId, row.agentId), row.sessionId),
+      await fs8.rm(
+        path7.join(scratchpadDir(deps2.config.root, row.projectId, row.agentId), row.sessionId),
         { recursive: true, force: true }
       );
       deps2.sessionsRepo.deleteById(row.sessionId);
@@ -3116,17 +3378,14 @@ function sessionsRoutes(deps2) {
   app2.get("/:sessionId/scratchpad/:fileName", async (c) => {
     const row = resolveSession(c);
     const fileName = c.req.param("fileName") ?? "";
-    if (!/^[A-Za-z0-9._-]+$/.test(fileName) || fileName.includes("..")) {
-      throw new HttpError(404, "file_not_found", "File does not exist.");
-    }
-    const filePath = path6.join(
-      scratchpadDir(deps2.config.root, row.projectId, row.agentId),
-      row.sessionId,
+    const filePath = resolveScratchpadFile(
+      path7.join(scratchpadDir(deps2.config.root, row.projectId, row.agentId), row.sessionId),
       fileName
     );
+    if (!filePath) throw new HttpError(404, "file_not_found", "File does not exist.");
     let bytes;
     try {
-      bytes = await fs7.readFile(filePath);
+      bytes = await fs8.readFile(filePath);
     } catch {
       throw new HttpError(404, "file_not_found", "File does not exist.");
     }
@@ -3137,9 +3396,21 @@ function sessionsRoutes(deps2) {
       ".gif": "image/gif",
       ".webp": "image/webp"
     };
-    const mime = MIME_BY_EXT[path6.extname(fileName).toLowerCase()] ?? "application/octet-stream";
+    const mime = MIME_BY_EXT[path7.extname(fileName).toLowerCase()];
     return c.body(new Uint8Array(bytes), 200, {
-      "content-type": mime,
+      "content-type": mime ?? "application/octet-stream",
+      // nosniff: the composer's file attachments land in this same directory, so the bytes
+      // here are arbitrary user content served from the App's own origin — without it a
+      // browser could sniff an `application/octet-stream` upload back into HTML and run it
+      // same-origin (the same defense workspace file reads apply).
+      "x-content-type-options": "nosniff",
+      // Second, independent layer for everything that fell off the allowlist: the only reason
+      // this endpoint is fetched inline is the conversation's <img> tags, so anything that is
+      // not one of those images is served as a download and never renders as a document —
+      // nosniff alone would be the whole defense otherwise.
+      ...mime === void 0 ? {
+        "content-disposition": `attachment; filename*=UTF-8''${encodeURIComponent(fileName)}`
+      } : {},
       "cache-control": "private, max-age=31536000, immutable"
     });
   });
@@ -3182,32 +3453,53 @@ function sessionsRoutes(deps2) {
     const goal = parseGoalField(body);
     const thinkingLevel = optionalEnum(body, "thinkingLevel", THINKING_LEVELS);
     if (goal) {
-      const input2 = parseTaskInput(body);
-      const text = input2.filter((m) => m.payload.type === "text").map((m) => m.payload.text).join("\n").trim();
-      if (!text || input2.some((m) => m.payload.type !== "text")) {
-        throw badRequest("goal mode requires text-only input (the objective).");
+      const { messages, attachments } = parseTaskInput(body);
+      const text = messages.filter((m) => m.payload.type === "text").map((m) => m.payload.text).join("\n").trim();
+      if (!text) {
+        throw badRequest("goal mode requires a non-empty text objective.");
+      }
+      if (attachments.length > 0) {
+        throw badRequest("goal mode accepts text and images only (no file attachments).");
       }
-      const { sessionId: sessionId2 } = await deps2.manager.startGoal(row.sessionId, {
-        input: input2,
+      const { sessionId } = await deps2.manager.startGoal(row.sessionId, {
+        input: messages,
         budget: goal.budget,
         ...thinkingLevel !== void 0 ? { thinkingLevel } : {}
       });
-      return c.json({ sessionId: sessionId2 }, 202);
+      return c.json({ sessionId }, 202);
     }
-    const input = parseTaskInput(body);
+    const parsed = parseTaskInput(body);
     const queueIfBusy = body.queueIfBusy === true;
-    const { sessionId, queued } = await deps2.manager.startTask(row.sessionId, input, {
-      ...thinkingLevel !== void 0 ? { thinkingLevel } : {},
-      queueIfBusy
-    });
-    return c.json({ sessionId, queued }, 202);
+    deps2.manager.assertCanAcceptTask(row.sessionId, { queueIfBusy });
+    const { input, written } = await attachFilesToInput(
+      parsed.messages,
+      parsed.attachments,
+      scratchpadDir(deps2.config.root, row.projectId, row.agentId),
+      row.sessionId
+    );
+    try {
+      const { sessionId, queued } = await deps2.manager.startTask(row.sessionId, input, {
+        ...thinkingLevel !== void 0 ? { thinkingLevel } : {},
+        queueIfBusy
+      });
+      return c.json({ sessionId, queued }, 202);
+    } catch (err) {
+      await removeAttachments(written);
+      throw err;
+    }
   });
   app2.post("/:sessionId/steer", async (c) => {
     const row = resolveSession(c);
     const body = await readJson(c);
     const text = typeof body.text === "string" ? body.text.trim() : "";
-    if (!text) throw badRequest("text must be a non-empty string.");
-    deps2.manager.steer(row.sessionId, text);
+    const images = parseSteerImages(body);
+    if (!text && images.length === 0) {
+      throw badRequest("text or images must carry the steering message.");
+    }
+    deps2.manager.steer(row.sessionId, [
+      ...text ? [userText(text)] : [],
+      ...images.map((url) => imageUrlMessage(url))
+    ]);
     return c.body(null, 202);
   });
   app2.get("/:sessionId/goal", (c) => {
@@ -3661,8 +3953,8 @@ var ErrorRecorder = class {
 };
 
 // src/runtime/session-manager.ts
-import fs8 from "fs/promises";
-import path8 from "path";
+import fs9 from "fs/promises";
+import path9 from "path";
 import {
   createAgent,
   findLatestTraceFile,
@@ -3922,14 +4214,26 @@ var SessionSources = class {
 
 // src/runtime/stream-error-watcher.ts
 import { isEventMessage, isModelMessage, isSessionMeta } from "@prismshadow/penguin-core";
-import path7 from "path";
+import path8 from "path";
 var TOOL_NAMES_MAX = 1e3;
 var ORIGIN_CTX_MAX = 200;
 var LLM_FAILURES = {
-  failed: { code: "llm_failed", kind: "unexpected", text: "LLM request failed (not retryable)." },
-  // Credentials rejection shares the failed bucket (no new taxonomy): same code/kind, the
-  // real reason arrives via the abort reason or the event's own message as usual.
-  auth: { code: "llm_failed", kind: "unexpected", text: "LLM request failed (not retryable)." },
+  // Reached here only when no further attempt followed: the ladder ran out (or the run ended
+  // on it), so the user lost the turn and someone should look. A `failed` that was retried
+  // takes LLM_FAILED_RETRIED instead.
+  failed: {
+    code: "llm_failed",
+    kind: "unexpected",
+    text: "LLM request failed and the retries did not recover it."
+  },
+  // Its own code, not the failed bucket: dedup is `(source, code, Project)` over a short
+  // window, and `llm_failed_retried` can now fire on any recovered blip — sharing a bucket
+  // would let a genuine credential failure be dropped as a duplicate of one.
+  auth: {
+    code: "llm_auth",
+    kind: "unexpected",
+    text: "LLM request rejected: the provider did not accept the credentials."
+  },
   timeout: {
     code: "llm_timeout",
     kind: "expected",
@@ -3941,12 +4245,23 @@ var LLM_FAILURES = {
     text: "LLM response could not be parsed (the engine reconnects and retries)."
   }
 };
+var LLM_FAILED_RETRIED = {
+  code: "llm_failed_retried",
+  kind: "expected",
+  text: "LLM request failed (the engine reconnects and retries)."
+};
 function isLlmFailure(s) {
   return s === "failed" || s === "timeout" || s === "malformed" || s === "auth";
 }
 function isToolFailure(s) {
   return s === "failed" || s === "timeout";
 }
+var COMMAND_TOOLS = /* @__PURE__ */ new Set(["exec_command", "input_command"]);
+var ORDINARY_EXIT_NOTE = /\[exit code: [^\]\n]*\]\s*$/;
+function isOrdinaryCommandExit(name, output) {
+  if (name !== void 0 && !COMMAND_TOOLS.has(name)) return false;
+  return ORDINARY_EXIT_NOTE.test(output);
+}
 function isUserAbortReason(reason) {
   return /^aborted\b/i.test(reason);
 }
@@ -4004,7 +4319,7 @@ var StreamErrorWatcher = class {
   registerOrigin(msg) {
     const key = originKey(msg);
     if (!key) return;
-    const agentId = path7.basename(path7.dirname(msg.payload.agent_state));
+    const agentId = path8.basename(path8.dirname(msg.payload.agent_state));
     if (!agentId || agentId === "." || agentId === "..") return;
     this.originCtx.delete(key);
     this.originCtx.set(key, { agentId, sessionId: key });
@@ -4041,7 +4356,7 @@ var StreamErrorWatcher = class {
       return;
     }
     if (p.type === "request_begin") {
-      this.flush(key);
+      this.flush(key, null, true);
       return;
     }
     if (p.type === "abort") {
@@ -4050,15 +4365,21 @@ var StreamErrorWatcher = class {
   }
   /**
    * Persist a pending LLM failure (no-op if none is pending); `reason` is the abort
-   * message that arrived afterward. Pending state is already bucketed by origin, so
+   * message that arrived afterward, and `retried` says whether another attempt followed
+   * (only a `request_begin` proves that). Pending state is already bucketed by origin, so
    * `key` is exactly "the session that produced this failure" — attribution is looked
    * up from it (see file header).
+   *
+   * `retried` defaults to false so every other resolution — an abort, the defensive flush at
+   * the next request_end, or close() at the end of the run — is read as "nothing came after
+   * this failure". That is the conservative direction: at worst a recovered blip is escalated,
+   * never a lost turn silently downgraded.
    */
-  flush(key, reason) {
+  flush(key, reason, retried = false) {
     const entry = this.pending.get(key);
     if (entry === void 0) return;
     this.pending.delete(key);
-    const spec = LLM_FAILURES[entry.status];
+    const spec = retried && entry.status === "failed" ? LLM_FAILED_RETRIED : LLM_FAILURES[entry.status];
     const trimmed = reason?.trim();
     const message = trimmed && !isUserAbortReason(trimmed) ? trimmed : entry.message ?? spec.text;
     this.errors.record({
@@ -4088,9 +4409,11 @@ var StreamErrorWatcher = class {
     const name = this.toolNames.get(key);
     this.toolNames.delete(key);
     if (!isToolFailure(p.stop_reason)) return;
+    const output = p.output ?? "";
+    if (isOrdinaryCommandExit(name, output)) return;
     this.errors.record({
       source: "environment",
-      err: toolFailureText(p.output ?? ""),
+      err: toolFailureText(output),
       ctx: this.ctxFor(origin),
       // The tool name goes into code: so the stats dashboard's "most common error code" and table can show which tool failed.
       code: `tool_${p.stop_reason}:${name ?? "unknown"}`,
@@ -4129,7 +4452,7 @@ function createCoreSessionLoader(root, sources) {
         }
       }
       try {
-        const stat = await fs8.stat(row.workspace);
+        const stat = await fs9.stat(row.workspace);
         if (!stat.isDirectory()) throw new Error("not a directory");
       } catch {
         throw new HttpError(
@@ -4305,6 +4628,23 @@ var SessionManager = class {
     for (const agentId of agentIds) this.invalidateAgentRuntimes(projectId, agentId);
   }
   // —— Task / compaction drive ——
+  /**
+   * Cheap, lock-free rehearsal of the 409/503 conditions startTask checks, throwing exactly the
+   * same HttpErrors. **Advisory only**: it neither takes the Session lock nor loads an entry, so
+   * a session that isn't in the active table reads as acceptable and a status change racing this
+   * call is not caught — the authoritative check is still the one inside startTask.
+   *
+   * It exists so a caller that has irreversible work to do first (POST /tasks writes the
+   * message's file attachments to disk) can find out about the ordinary "a Task is already
+   * running" rejection before doing it, instead of undoing it afterwards.
+   */
+  assertCanAcceptTask(sessionId, opts) {
+    this.assertOpen();
+    this.assertAgentNotDeleting(sessionId);
+    this.assertSessionNotDeleting(sessionId);
+    const entry = this.entries.get(sessionId);
+    if (entry && !opts?.queueIfBusy) this.assertIdle(entry);
+  }
   /**
    * Start a Task: get-or-load → 409
    * mutual-exclusion check → publish the input messages first → drive run in the
@@ -4543,15 +4883,16 @@ var SessionManager = class {
     return entry.approvals.decide(toolCallId, decision);
   }
   /**
-   * Mid-run steering: forward the text to the running Session (core delivers it between
-   * turns as a standalone `[user_steering]` user message — no SSE event of its own; the
-   * message arrives through the stream the drive loop already publishes). 409 when the
-   * Session isn't running a Task (idle / compacting / not loaded) or the run finished in the
-   * race window — the caller falls back to submitting a normal task.
+   * Mid-run steering: forward the message to the running Session (core delivers it between
+   * turns as a standalone `[user_steering]` user message followed by its images — no SSE
+   * event of its own; the messages arrive through the stream the drive loop already
+   * publishes). 409 when the Session isn't running a Task (idle / compacting / not loaded)
+   * or the run finished in the race window — the caller falls back to submitting a normal
+   * task, which carries the same text and images.
    */
-  steer(sessionId, text) {
+  steer(sessionId, input) {
     const entry = this.entries.get(sessionId);
-    if (!entry || entry.status !== "running" || !entry.session.steer(text)) {
+    if (!entry || entry.status !== "running" || !entry.session.steer(input)) {
       throw new HttpError(
         409,
         "not_running",
@@ -4915,7 +5256,7 @@ var SessionManager = class {
     const childSid = msg.origin[msg.origin.length - 1];
     if (children.has(childSid)) return null;
     const p = msg.payload;
-    const agentId = path8.basename(path8.dirname(p.agent_state));
+    const agentId = path9.basename(path9.dirname(p.agent_state));
     if (!agentId || agentId === "." || agentId === "..") return null;
     const source = asSessionSource(p.source) ?? "subagent";
     this.deps.sources.set(childSid, source);
@@ -5394,7 +5735,7 @@ var UsageRecorder = class {
 };
 
 // src/services/ids.ts
-import { randomBytes as randomBytes4 } from "crypto";
+import { randomBytes as randomBytes5 } from "crypto";
 var SEMANTIC_ID_PATTERN = /^[a-z][a-z0-9_]{1,63}$/;
 var USERNAME_PATTERN = /^[a-z][a-z0-9_]{1,31}$/;
 var PROJECT_SUFFIX_PATTERN = /^[a-z0-9_]+$/;
@@ -5470,7 +5811,7 @@ var AdminService = class {
 };
 
 // src/services/agent-config-service.ts
-import fs10 from "fs/promises";
+import fs11 from "fs/promises";
 import { parseDocument, parse as parseYaml } from "yaml";
 import {
   agentsMdPath,
@@ -5485,8 +5826,8 @@ import {
 } from "@prismshadow/penguin-core";
 
 // src/services/project-config-service.ts
-import fs9 from "fs/promises";
-import path9 from "path";
+import fs10 from "fs/promises";
+import path10 from "path";
 import { parse as parseToml2 } from "smol-toml";
 import {
   GenerativeModel,
@@ -5545,7 +5886,7 @@ var ProjectConfigService = class {
    */
   async configUpdatedAt(projectId) {
     try {
-      const st = await fs9.stat(this.filePath(projectId));
+      const st = await fs10.stat(this.filePath(projectId));
       return st.mtime.toISOString();
     } catch {
       return void 0;
@@ -5555,7 +5896,7 @@ var ProjectConfigService = class {
   async readRaw(projectId) {
     let raw;
     try {
-      raw = await fs9.readFile(this.filePath(projectId), "utf8");
+      raw = await fs10.readFile(this.filePath(projectId), "utf8");
     } catch (err) {
       if (err.code === "ENOENT") return {};
       throw err;
@@ -5570,9 +5911,9 @@ var ProjectConfigService = class {
    */
   async writeRaw(projectId, data) {
     const file = this.filePath(projectId);
-    await fs9.mkdir(path9.dirname(file), { recursive: true });
-    await fs9.writeFile(file, renderProjectConfigToml(data), { encoding: "utf8", mode: 384 });
-    await fs9.chmod(file, 384);
+    await fs10.mkdir(path10.dirname(file), { recursive: true });
+    await fs10.writeFile(file, renderProjectConfigToml(data), { encoding: "utf8", mode: 384 });
+    await fs10.chmod(file, 384);
   }
   /**
    * Initial config for a newly created Project: display name + preset built-in
@@ -5616,6 +5957,15 @@ var ProjectConfigService = class {
     const raw = await this.readRaw(projectId);
     return typeof raw.name === "string" ? raw.name : void 0;
   }
+  /**
+   * Rewrites the display name, preserving every other field (models, credentials, default
+   * model): read-modify-write of the same toml, like ensurePresetModels. The id itself is
+   * immutable — only this label changes.
+   */
+  async setName(projectId, name) {
+    const raw = await this.readRaw(projectId);
+    await this.writeRaw(projectId, { ...raw, name });
+  }
   /** Paired reference of the default Model; returns undefined if unconfigured (or in the old string format). */
   async getDefaultModelRef(projectId) {
     const raw = await this.readRaw(projectId);
@@ -5936,7 +6286,7 @@ var AgentConfigService = class {
   /** Whether the Agent exists (determined by the presence of system_config.yaml, matching the CLI's convention). */
   async exists(projectId, agentId) {
     try {
-      await fs10.access(systemConfigPath(this.root, projectId, agentId));
+      await fs11.access(systemConfigPath(this.root, projectId, agentId));
       return true;
     } catch {
       return false;
@@ -5954,7 +6304,7 @@ var AgentConfigService = class {
    */
   async readCardMeta(projectId, agentId) {
     try {
-      const raw = await fs10.readFile(systemConfigPath(this.root, projectId, agentId), "utf8");
+      const raw = await fs11.readFile(systemConfigPath(this.root, projectId, agentId), "utf8");
       const parsed = asRecord(parseYaml(raw));
       const tools = asRecord(parsed.tools);
       const countOf = (v) => Array.isArray(v) ? v.length : 0;
@@ -5972,14 +6322,14 @@ var AgentConfigService = class {
   async getConfig(projectId, agentId) {
     await this.requireExists(projectId, agentId);
     const yamlPath = systemConfigPath(this.root, projectId, agentId);
-    const systemConfigYaml = await fs10.readFile(yamlPath, "utf8");
+    const systemConfigYaml = await fs11.readFile(yamlPath, "utf8");
     const parsed = asRecord(parseYaml(systemConfigYaml));
     const model = asRecord(parsed.model);
     const compaction = asRecord(parsed.compaction);
     const tools = asRecord(parsed.tools);
     let agentsMd = "";
     try {
-      agentsMd = await fs10.readFile(agentsMdPath(this.root, projectId, agentId), "utf8");
+      agentsMd = await fs11.readFile(agentsMdPath(this.root, projectId, agentId), "utf8");
     } catch {
     }
     const modelDto = {
@@ -6022,7 +6372,7 @@ var AgentConfigService = class {
       await this.applyConfigUpdate(projectId, agentId, req.config);
     }
     if (req.agentsMd !== void 0) {
-      await fs10.writeFile(agentsMdPath(this.root, projectId, agentId), req.agentsMd, "utf8");
+      await fs11.writeFile(agentsMdPath(this.root, projectId, agentId), req.agentsMd, "utf8");
     }
   }
   /**
@@ -6040,9 +6390,9 @@ var AgentConfigService = class {
   async applyConfigUpdate(projectId, agentId, config2) {
     const cfg = config2;
     const yamlPath = systemConfigPath(this.root, projectId, agentId);
-    const doc = parseDocument(await fs10.readFile(yamlPath, "utf8"));
-    const setIfProvided = (path17, value) => {
-      if (value !== void 0) doc.setIn(path17, value);
+    const doc = parseDocument(await fs11.readFile(yamlPath, "utf8"));
+    const setIfProvided = (path18, value) => {
+      if (value !== void 0) doc.setIn(path18, value);
     };
     setIfProvided(["name"], optionalString(cfg, "name", { maxLen: 100, label: "name" }));
     setIfProvided(
@@ -6091,7 +6441,7 @@ var AgentConfigService = class {
     if (cfg.mcpServers !== void 0) {
       doc.setIn(["tools", "mcpServers"], validateMcpServers(cfg.mcpServers));
     }
-    await fs10.writeFile(yamlPath, doc.toString(), "utf8");
+    await fs11.writeFile(yamlPath, doc.toString(), "utf8");
   }
   /** Read the Agent vault (agent_state/.vault.toml): values are always masked, plaintext is never sent to the client. */
   async getVault(projectId, agentId) {
@@ -6188,8 +6538,8 @@ function validateMcpServers(value) {
 }
 
 // src/services/agent-service.ts
-import fs11 from "fs/promises";
-import path10 from "path";
+import fs12 from "fs/promises";
+import path11 from "path";
 import {
   agentDir,
   agentsDir as agentsDir2,
@@ -6216,7 +6566,7 @@ var AgentService = class {
     const known = new Map(this.agents.list(projectId).map((r) => [r.agentId, r]));
     let entries = [];
     try {
-      const dirents = await fs11.readdir(agentsDir2(this.root, projectId), { withFileTypes: true });
+      const dirents = await fs12.readdir(agentsDir2(this.root, projectId), { withFileTypes: true });
       entries = dirents.filter((d) => d.isDirectory()).map((d) => d.name);
     } catch {
     }
@@ -6225,7 +6575,7 @@ var AgentService = class {
       const configPath = systemConfigPath2(this.root, projectId, agentId);
       let createdAt;
       try {
-        const stat = await fs11.stat(configPath);
+        const stat = await fs12.stat(configPath);
         createdAt = (stat.birthtime.getTime() > 0 ? stat.birthtime : stat.mtime).toISOString();
       } catch {
         continue;
@@ -6269,7 +6619,7 @@ var AgentService = class {
   /** Number of scheduled tasks: count of .toml files under schedule/ (0 if the directory doesn't exist). */
   async scheduleCount(projectId, agentId) {
     try {
-      const names = await fs11.readdir(scheduleDir2(this.root, projectId, agentId));
+      const names = await fs12.readdir(scheduleDir2(this.root, projectId, agentId));
       return names.filter((n) => n.endsWith(".toml")).length;
     } catch {
       return 0;
@@ -6280,14 +6630,14 @@ var AgentService = class {
     const base = skillsDir2(this.root, projectId, agentId);
     let dirents;
     try {
-      dirents = await fs11.readdir(base, { withFileTypes: true });
+      dirents = await fs12.readdir(base, { withFileTypes: true });
     } catch {
       return 0;
     }
     const present = await Promise.all(
       dirents.filter((d) => d.isDirectory()).map(async (d) => {
         try {
-          await fs11.access(path10.join(base, d.name, "SKILL.md"));
+          await fs12.access(path11.join(base, d.name, "SKILL.md"));
           return true;
         } catch {
           return false;
@@ -6305,7 +6655,7 @@ var AgentService = class {
     const times = await Promise.all(
       paths.map(async (p) => {
         try {
-          return (await fs11.stat(p)).mtime.getTime();
+          return (await fs12.stat(p)).mtime.getTime();
         } catch {
           return 0;
         }
@@ -6330,7 +6680,7 @@ var AgentService = class {
         "Built-in Agents (default_agent) are provisioned with the Project and cannot be deleted from the web."
       );
     }
-    await fs11.rm(agentDir(this.root, projectId, agentId), { recursive: true, force: true });
+    await fs12.rm(agentDir(this.root, projectId, agentId), { recursive: true, force: true });
     this.agents.delete(projectId, agentId);
   }
   /**
@@ -6347,7 +6697,7 @@ var AgentService = class {
         `Agent id must be 2\u201364 characters: ${SEMANTIC_ID_RULE}.`
       );
     }
-    const taken = this.agents.exists(projectId, agentId) || await fs11.stat(agentDir(this.root, projectId, agentId)).then(
+    const taken = this.agents.exists(projectId, agentId) || await fs12.stat(agentDir(this.root, projectId, agentId)).then(
       () => true,
       () => false
     );
@@ -6361,7 +6711,7 @@ var AgentService = class {
         config: { name: displayName, ...description !== void 0 ? { description } : {} }
       });
     } catch (err) {
-      await fs11.rm(agentDir(this.root, projectId, agentId), { recursive: true, force: true }).catch(() => {
+      await fs12.rm(agentDir(this.root, projectId, agentId), { recursive: true, force: true }).catch(() => {
       });
       throw err;
     }
@@ -6385,120 +6735,205 @@ var AgentService = class {
 };
 
 // src/services/benchmark-service.ts
-import fs12 from "fs/promises";
-import path11 from "path";
+import fs13 from "fs/promises";
+import path12 from "path";
 import { parse as parseToml3 } from "smol-toml";
 import { parse as parseYaml2 } from "yaml";
 import { benchmarksDir } from "@prismshadow/penguin-core";
+var STATEMENT_TITLE_READ_BYTES = 64 * 1024;
 function asRecord2(v) {
   return v !== null && typeof v === "object" && !Array.isArray(v) ? v : {};
 }
 function numberOr(v) {
   return typeof v === "number" && Number.isFinite(v) ? v : void 0;
 }
+function scoreOr(v) {
+  const value = numberOr(v);
+  return value !== void 0 && value >= 0 && value <= 100 ? value : void 0;
+}
+function nonNegativeOr(v) {
+  const value = numberOr(v);
+  return value !== void 0 && value >= 0 ? value : void 0;
+}
+function nonNegativeIntegerOr(v) {
+  const value = nonNegativeOr(v);
+  return value !== void 0 && Number.isInteger(value) ? value : void 0;
+}
+function nullableCostOr(v) {
+  if (v === null) return null;
+  return nonNegativeOr(v);
+}
 function stringOr(v) {
   return typeof v === "string" && v !== "" ? v : void 0;
 }
+function isWithin(parent, child) {
+  const relative = path12.relative(parent, child);
+  return relative !== "" && !relative.startsWith("..") && !path12.isAbsolute(relative);
+}
+function statementTitle(statement, fallback) {
+  const heading = /^#\s+(.+)$/m.exec(statement)?.[1]?.trim();
+  return heading?.replace(/^Case\s+\d+\s*:\s*/i, "") || fallback;
+}
+async function readStatementTitle(readme, fallback) {
+  const handle = await fs13.open(readme, "r");
+  try {
+    const buffer = Buffer.alloc(STATEMENT_TITLE_READ_BYTES);
+    const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+    return statementTitle(buffer.subarray(0, bytesRead).toString("utf8"), fallback);
+  } finally {
+    await handle.close();
+  }
+}
 function toRun(v) {
   const r = asRecord2(v);
-  const score = numberOr(r.score);
-  if (score === void 0) return null;
-  const cost = numberOr(r.cost);
-  const durationMs = numberOr(r.duration_ms);
+  const score = scoreOr(r.score);
+  const cost = nullableCostOr(r.cost);
+  const durationMs = nonNegativeIntegerOr(r.duration_ms);
   const sessionId = stringOr(r.session_id);
-  return {
-    score,
-    ...cost !== void 0 ? { cost } : {},
-    ...durationMs !== void 0 ? { durationMs } : {},
-    ...sessionId !== void 0 ? { sessionId } : {}
-  };
-}
-function averageOf(runs, pick) {
-  const values = runs.map(pick).filter((v) => v !== void 0);
-  if (values.length === 0) return void 0;
-  return values.reduce((a, b) => a + b, 0) / values.length;
+  if (score === void 0 || cost === void 0 || durationMs === void 0 || !sessionId)
+    return null;
+  return { score, cost, durationMs, sessionId };
 }
 function toCase(v) {
   const cr = asRecord2(v);
   const caseId = stringOr(cr.case);
-  if (caseId === void 0) return null;
-  const parsedRuns = Array.isArray(cr.runs) ? cr.runs.map(toRun).filter((r) => r !== null) : [];
-  const score = numberOr(cr.score) ?? averageOf(parsedRuns, (r) => r.score);
-  if (score === void 0) return null;
-  const cost = numberOr(cr.cost) ?? averageOf(parsedRuns, (r) => r.cost);
-  const durationMs = numberOr(cr.duration_ms) ?? averageOf(parsedRuns, (r) => r.durationMs);
-  const sessionId = stringOr(cr.session_id);
-  const runs = parsedRuns.length > 0 ? parsedRuns : [
-    // The old format is parsed as a single run: the case-level values are that run's raw result.
-    {
-      score,
-      ...cost !== void 0 ? { cost } : {},
-      ...durationMs !== void 0 ? { durationMs } : {},
-      ...sessionId !== void 0 ? { sessionId } : {}
-    }
-  ];
+  const score = scoreOr(cr.score);
+  const cost = nullableCostOr(cr.cost);
+  const durationMs = nonNegativeIntegerOr(cr.duration_ms);
+  if (!caseId || score === void 0 || cost === void 0 || durationMs === void 0 || "max_score" in cr || !Array.isArray(cr.runs) || cr.runs.length === 0) {
+    return null;
+  }
+  const parsedRuns = cr.runs.map(toRun);
+  if (parsedRuns.some((run) => run === null)) return null;
+  const runs = parsedRuns;
   return {
     case: caseId,
     score,
-    ...cost !== void 0 ? { cost } : {},
-    ...durationMs !== void 0 ? { durationMs } : {},
-    ...sessionId !== void 0 ? { sessionId } : {},
+    cost,
+    durationMs,
     runs
   };
 }
 function toEvaluation(v) {
   const r = asRecord2(v);
   const time = r.time instanceof Date ? r.time.toISOString() : r.time;
-  const score = numberOr(r.score);
-  if (typeof time !== "string" || time === "" || score === void 0) return null;
-  const cases = Array.isArray(r.cases) ? r.cases.map(toCase).filter((c) => c !== null) : [];
+  const score = scoreOr(r.score);
+  const cost = nullableCostOr(r.cost);
+  const durationMs = nonNegativeIntegerOr(r.duration_ms);
   const summary = stringOr(r.summary);
   const summaryTitle = stringOr(r.summary_title);
   const modelId = stringOr(r.model_id);
   const provider = stringOr(r.provider);
-  const version = numberOr(r.version);
-  const cost = numberOr(r.cost);
-  const durationMs = numberOr(r.duration_ms);
+  const thinkingLevel = stringOr(r.thinking_level);
+  const version = nonNegativeIntegerOr(r.version);
+  if (typeof time !== "string" || time === "" || score === void 0 || cost === void 0 || durationMs === void 0 || !modelId || !provider || !thinkingLevel || version === void 0 || version < 1 || !Array.isArray(r.cases) || r.cases.length === 0) {
+    return null;
+  }
+  const parsedCases = r.cases.map(toCase);
+  if (parsedCases.some((item) => item === null)) return null;
+  const cases = parsedCases;
   return {
     time,
     ...summaryTitle !== void 0 ? { summaryTitle } : {},
     ...summary !== void 0 ? { summary } : {},
-    ...modelId !== void 0 ? { modelId } : {},
-    ...provider !== void 0 ? { provider } : {},
+    modelId,
+    provider,
+    thinkingLevel,
     score,
-    ...version !== void 0 ? { version } : {},
-    ...cost !== void 0 ? { cost } : {},
-    ...durationMs !== void 0 ? { durationMs } : {},
+    version,
+    cost,
+    durationMs,
     cases
   };
 }
 var BenchmarkService = class {
-  constructor(root) {
+  constructor(root, workspaceFiles) {
     this.root = root;
+    this.workspaceFiles = workspaceFiles;
   }
   root;
+  workspaceFiles;
   async list(projectId, agentId) {
     const dir = benchmarksDir(this.root, projectId, agentId);
     let items;
     try {
-      const entries = await fs12.readdir(dir, { withFileTypes: true });
+      const entries = await fs13.readdir(dir, { withFileTypes: true });
       items = entries.map((e) => ({ name: e.name, isDir: e.isDirectory() }));
     } catch {
       return { benchmarks: [] };
     }
     const benchmarks = [];
     for (const item of items.filter((i) => i.isDir).sort((a, b) => a.name.localeCompare(b.name))) {
-      benchmarks.push(await this.readBenchmark(path11.join(dir, item.name), item.name));
+      benchmarks.push(await this.readBenchmark(path12.join(dir, item.name), item.name));
     }
     return { benchmarks };
   }
+  async listCases(projectId, agentId, benchmarkId) {
+    const baseDir = benchmarksDir(this.root, projectId, agentId);
+    const benchDir = path12.join(baseDir, benchmarkId);
+    let entries;
+    let realBaseDir;
+    let realBenchDir;
+    try {
+      [entries, realBaseDir, realBenchDir] = await Promise.all([
+        fs13.readdir(benchDir, { withFileTypes: true }),
+        fs13.realpath(baseDir),
+        fs13.realpath(benchDir)
+      ]);
+    } catch {
+      return { cases: [] };
+    }
+    if (!isWithin(realBaseDir, realBenchDir)) return { cases: [] };
+    const cases = [];
+    for (const entry of entries.filter((item) => item.isDirectory() && item.name.startsWith("CASE-")).sort((a, b) => a.name.localeCompare(b.name))) {
+      const fallback = { id: entry.name, title: entry.name };
+      try {
+        const statementDir = await this.statementRoot(projectId, agentId, benchmarkId, entry.name);
+        const realReadme = await fs13.realpath(path12.join(statementDir, "README.md"));
+        if (!isWithin(statementDir, realReadme)) throw new Error("README escapes Statement");
+        cases.push({
+          id: entry.name,
+          title: await readStatementTitle(realReadme, entry.name)
+        });
+      } catch {
+        cases.push(fallback);
+      }
+    }
+    return { cases };
+  }
+  async listCaseFiles(projectId, agentId, benchmarkId, caseId, rel) {
+    const statementDir = await this.statementRoot(projectId, agentId, benchmarkId, caseId);
+    return this.workspaceFiles.list(statementDir, rel);
+  }
+  async readCaseFile(projectId, agentId, benchmarkId, caseId, rel, options) {
+    const statementDir = await this.statementRoot(projectId, agentId, benchmarkId, caseId);
+    return this.workspaceFiles.read(statementDir, rel, options);
+  }
+  async statementRoot(projectId, agentId, benchmarkId, caseId) {
+    const benchDir = path12.join(benchmarksDir(this.root, projectId, agentId), benchmarkId);
+    const caseDir = path12.join(benchDir, caseId);
+    const statementDir = path12.join(caseDir, "statement");
+    try {
+      const [realBenchDir, realCaseDir, realStatementDir] = await Promise.all([
+        fs13.realpath(benchDir),
+        fs13.realpath(caseDir),
+        fs13.realpath(statementDir)
+      ]);
+      if (!isWithin(realBenchDir, realCaseDir) || path12.dirname(realStatementDir) !== realCaseDir || path12.basename(realStatementDir) !== "statement") {
+        throw new Error("Statement path is not canonical");
+      }
+      return realStatementDir;
+    } catch {
+      throw new HttpError(404, "not_found", "Public Case Statement does not exist.");
+    }
+  }
   async readBenchmark(benchDir, id) {
     let title = id;
     let description;
     let runs;
     try {
       const config2 = asRecord2(
-        parseToml3(await fs12.readFile(path11.join(benchDir, "benchmark_config.toml"), "utf8"))
+        parseToml3(await fs13.readFile(path12.join(benchDir, "benchmark_config.toml"), "utf8"))
       );
       if (typeof config2.title === "string" && config2.title !== "") title = config2.title;
       if (typeof config2.description === "string" && config2.description !== "") {
@@ -6513,7 +6948,7 @@ var BenchmarkService = class {
     let evaluations = [];
     try {
       const scoreboard = asRecord2(
-        parseYaml2(await fs12.readFile(path11.join(benchDir, "scoreboard.yaml"), "utf8"))
+        parseYaml2(await fs13.readFile(path12.join(benchDir, "scoreboard.yaml"), "utf8"))
       );
       if (Array.isArray(scoreboard.evaluations)) {
         evaluations = scoreboard.evaluations.map(toEvaluation).filter((e) => e !== null);
@@ -6522,8 +6957,8 @@ var BenchmarkService = class {
     }
     let caseCount = 0;
     try {
-      const entries = await fs12.readdir(benchDir, { withFileTypes: true });
-      caseCount = entries.filter((e) => e.isDirectory()).length;
+      const entries = await fs13.readdir(benchDir, { withFileTypes: true });
+      caseCount = entries.filter((e) => e.isDirectory() && e.name.startsWith("CASE-")).length;
     } catch {
     }
     return {
@@ -6538,9 +6973,9 @@ var BenchmarkService = class {
 };
 
 // src/services/snapshot-service.ts
-import { randomBytes as randomBytes5 } from "crypto";
-import fs13 from "fs/promises";
-import path12 from "path";
+import { randomBytes as randomBytes6 } from "crypto";
+import fs14 from "fs/promises";
+import path13 from "path";
 import * as tar from "tar";
 import { parse as parseYaml3 } from "yaml";
 import {
@@ -6553,7 +6988,7 @@ import {
 } from "@prismshadow/penguin-core";
 var VAULT_BASENAME = ".vault.toml";
 function isVaultEntry(entryPath) {
-  return path12.posix.basename(entryPath.replaceAll("\\", "/")) === VAULT_BASENAME;
+  return path13.posix.basename(entryPath.replaceAll("\\", "/")) === VAULT_BASENAME;
 }
 var SnapshotService = class {
   constructor(root) {
@@ -6564,7 +6999,7 @@ var SnapshotService = class {
   async currentVersion(projectId, agentId) {
     let raw;
     try {
-      raw = await fs13.readFile(systemConfigPath3(this.root, projectId, agentId), "utf8");
+      raw = await fs14.readFile(systemConfigPath3(this.root, projectId, agentId), "utf8");
     } catch {
       throw new HttpError(404, "agent_not_found", "Agent does not exist.");
     }
@@ -6577,14 +7012,14 @@ var SnapshotService = class {
   async ensureSnapshot(projectId, agentId) {
     const version = await this.currentVersion(projectId, agentId);
     const dir = snapshotsDir(this.root, projectId, agentId);
-    const file = path12.join(dir, `v${version}.tar.gz`);
+    const file = path13.join(dir, `v${version}.tar.gz`);
     try {
-      await fs13.access(file);
+      await fs14.access(file);
       return { version, file };
     } catch {
     }
-    await fs13.mkdir(dir, { recursive: true });
-    const tmp = `${file}.tmp-${randomBytes5(4).toString("hex")}`;
+    await fs14.mkdir(dir, { recursive: true });
+    const tmp = `${file}.tmp-${randomBytes6(4).toString("hex")}`;
     await tar.create(
       {
         gzip: true,
@@ -6595,7 +7030,7 @@ var SnapshotService = class {
       },
       ["agent_state"]
     );
-    await fs13.rename(tmp, file);
+    await fs14.rename(tmp, file);
     return { version, file };
   }
   /** Export: automatically packs a snapshot first if none exists, returns the info needed for download. */
@@ -6612,13 +7047,13 @@ var SnapshotService = class {
   async importArchive(projectId, agentId, archive, confirm) {
     const current = await this.currentVersion(projectId, agentId);
     const base = agentDir2(this.root, projectId, agentId);
-    const staging = path12.join(base, `.import-${randomBytes5(6).toString("hex")}`);
-    await fs13.mkdir(staging, { recursive: true });
+    const staging = path13.join(base, `.import-${randomBytes6(6).toString("hex")}`);
+    await fs14.mkdir(staging, { recursive: true });
     try {
-      const archiveFile = path12.join(staging, "archive.tar.gz");
-      await fs13.writeFile(archiveFile, archive);
-      const extractDir = path12.join(staging, "extracted");
-      await fs13.mkdir(extractDir, { recursive: true });
+      const archiveFile = path13.join(staging, "archive.tar.gz");
+      await fs14.writeFile(archiveFile, archive);
+      const extractDir = path13.join(staging, "extracted");
+      await fs14.mkdir(extractDir, { recursive: true });
       try {
         await tar.extract({
           file: archiveFile,
@@ -6628,10 +7063,10 @@ var SnapshotService = class {
       } catch {
         throw badRequest("Import failed: not a valid tar.gz snapshot package.");
       }
-      const configPath = path12.join(extractDir, "agent_state", "system_config.yaml");
+      const configPath = path13.join(extractDir, "agent_state", "system_config.yaml");
       let parsed;
       try {
-        parsed = parseYaml3(await fs13.readFile(configPath, "utf8"));
+        parsed = parseYaml3(await fs14.readFile(configPath, "utf8"));
       } catch {
         throw badRequest("Import failed: the package is missing agent_state/system_config.yaml.");
       }
@@ -6654,37 +7089,37 @@ var SnapshotService = class {
       }
       await this.ensureSnapshot(projectId, agentId);
       const stateDir = agentStateDir2(this.root, projectId, agentId);
-      const incomingState = path12.join(extractDir, "agent_state");
+      const incomingState = path13.join(extractDir, "agent_state");
       let vault = null;
       try {
-        vault = await fs13.readFile(agentVaultPath(this.root, projectId, agentId));
+        vault = await fs14.readFile(agentVaultPath(this.root, projectId, agentId));
       } catch {
       }
       if (vault !== null) {
-        await fs13.writeFile(path12.join(incomingState, VAULT_BASENAME), vault, { mode: 384 });
+        await fs14.writeFile(path13.join(incomingState, VAULT_BASENAME), vault, { mode: 384 });
       }
-      const trash = path12.join(staging, "replaced-agent_state");
-      await fs13.rename(stateDir, trash);
+      const trash = path13.join(staging, "replaced-agent_state");
+      await fs14.rename(stateDir, trash);
       try {
-        await fs13.rename(incomingState, stateDir);
+        await fs14.rename(incomingState, stateDir);
       } catch (err) {
-        await fs13.rename(trash, stateDir);
+        await fs14.rename(trash, stateDir);
         throw err;
       }
       return { version: incoming };
     } finally {
-      await fs13.rm(staging, { recursive: true, force: true });
+      await fs14.rm(staging, { recursive: true, force: true });
     }
   }
 };
 
 // src/services/project-service.ts
-import fs14 from "fs/promises";
+import fs15 from "fs/promises";
 import { DEFAULT_PROJECT_ID, projectDir, provisionProjectAgents } from "@prismshadow/penguin-core";
 var ABORT_SETTLE_TIMEOUT_MS = 5e3;
-async function dirExists(path17) {
+async function dirExists(path18) {
   try {
-    const stat = await fs14.stat(path17);
+    const stat = await fs15.stat(path18);
     return stat.isDirectory();
   } catch {
     return false;
@@ -6809,12 +7244,12 @@ var ProjectService = class {
       throw err;
     }
     try {
-      await fs14.mkdir(projectDir(this.deps.root, projectId), { recursive: true });
+      await fs15.mkdir(projectDir(this.deps.root, projectId), { recursive: true });
       await this.deps.projectConfig.writeInitialConfig(projectId, displayName);
       await this.provisionBuiltinAgents(projectId);
     } catch (err) {
       this.deps.projects.delete(projectId);
-      await fs14.rm(projectDir(this.deps.root, projectId), { recursive: true, force: true }).catch(() => {
+      await fs15.rm(projectDir(this.deps.root, projectId), { recursive: true, force: true }).catch(() => {
       });
       throw err;
     }
@@ -6847,6 +7282,23 @@ var ProjectService = class {
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     });
   }
+  /**
+   * Rename a Project's display name (owner): the id stays immutable — it names the directory,
+   * the Workspace paths and every stored reference — so only the label in project_config.toml
+   * changes. Returns the refreshed summary so the caller can swap it into its list without a
+   * reload.
+   */
+  async renameProject(userId, projectId, name) {
+    const row = this.requireProjectOwner(userId, projectId);
+    await this.deps.projectConfig.setName(projectId, name);
+    return {
+      projectId,
+      name,
+      role: "owner",
+      ownerUserId: row.ownerUserId,
+      createdAt: row.createdAt
+    };
+  }
   /**
    * Delete a Project (owner): default_project is refused; deleting the user's
    * **last accessible Project** is refused too (deleting it would leave the list
@@ -6895,7 +7347,7 @@ var ProjectService = class {
     this.deps.errors.deleteByProject(projectId);
     this.deps.schedules.deleteByProject(projectId);
     this.deps.goals.deleteByProject(projectId);
-    await fs14.rm(projectDir(this.deps.root, projectId), { recursive: true, force: true });
+    await fs15.rm(projectDir(this.deps.root, projectId), { recursive: true, force: true });
   }
   // —— Member authorization ——
   /** Member list: owner (role=owner) + members. */
@@ -6966,7 +7418,7 @@ var ProjectService = class {
 };
 
 // src/services/session-service.ts
-import path13 from "path";
+import path14 from "path";
 import { open, readdir as readdir2 } from "fs/promises";
 import {
   createAgent as createAgent2,
@@ -7148,7 +7600,7 @@ var SessionService = class {
     };
     const dir = tracesDir2(this.deps.root, projectId, agentId);
     for (const dateDir of await listDirsSafe(dir)) {
-      for (const file of await listFilesSafe(path13.join(dir, dateDir))) {
+      for (const file of await listFilesSafe(path14.join(dir, dateDir))) {
         const match = TRACE_FILE_RE.exec(file);
         if (match) mark(dateDir, match[1]);
       }
@@ -7264,14 +7716,14 @@ var SessionService = class {
     const dir = tracesDir2(this.deps.root, projectId, agentId);
     const out = /* @__PURE__ */ new Map();
     for (const dateDir of await listDirsSafe(dir)) {
-      for (const file of await listFilesSafe(path13.join(dir, dateDir))) {
+      for (const file of await listFilesSafe(path14.join(dir, dateDir))) {
         const match = TRACE_FILE_RE.exec(file);
         if (!match) continue;
         const sessionId = match[1];
         const index = Number(match[2]);
         const cur = out.get(sessionId);
         if (!cur || index < cur.index) {
-          out.set(sessionId, { path: path13.join(dir, dateDir, file), index });
+          out.set(sessionId, { path: path14.join(dir, dateDir, file), index });
         }
       }
     }
@@ -7334,8 +7786,8 @@ async function listFilesSafe(dir) {
 }
 
 // src/services/trace-service.ts
-import fs15 from "fs/promises";
-import path14 from "path";
+import fs16 from "fs/promises";
+import path15 from "path";
 import {
   agentsDir as agentsDir3,
   isSessionMeta as isSessionMeta5,
@@ -7357,7 +7809,7 @@ function subagentPointer(msg) {
 }
 async function listDirs(dir) {
   try {
-    const entries = await fs15.readdir(dir, { withFileTypes: true });
+    const entries = await fs16.readdir(dir, { withFileTypes: true });
     return entries.filter((e) => e.isDirectory()).map((e) => e.name);
   } catch {
     return [];
@@ -7365,7 +7817,7 @@ async function listDirs(dir) {
 }
 async function listFiles(dir) {
   try {
-    const entries = await fs15.readdir(dir, { withFileTypes: true });
+    const entries = await fs16.readdir(dir, { withFileTypes: true });
     return entries.filter((e) => e.isFile()).map((e) => e.name);
   } catch {
     return [];
@@ -7381,10 +7833,10 @@ var TraceService = class {
     const dir = tracesDir3(this.root, projectId, agentId);
     const out = [];
     for (const dateDir of await listDirs(dir)) {
-      for (const file of await listFiles(path14.join(dir, dateDir))) {
+      for (const file of await listFiles(path15.join(dir, dateDir))) {
         const match = TRACE_FILE_RE2.exec(file);
         if (!match || match[1] !== sessionId) continue;
-        out.push({ path: path14.join(dir, dateDir, file), date: dateDir, index: Number(match[2]) });
+        out.push({ path: path15.join(dir, dateDir, file), date: dateDir, index: Number(match[2]) });
       }
     }
     return out.sort((a, b) => a.index - b.index);
@@ -7393,7 +7845,7 @@ var TraceService = class {
   async deleteSessionTraces(projectId, agentId, sessionId) {
     const files = await this.locateAll(projectId, agentId, sessionId);
     for (const file of files) {
-      await fs15.rm(file.path, { force: true });
+      await fs16.rm(file.path, { force: true });
     }
   }
   /**
@@ -7431,7 +7883,7 @@ var TraceService = class {
     for (const agentId of await listDirs(agentsDir3(this.root, projectId))) {
       const dir = tracesDir3(this.root, projectId, agentId);
       for (const dateDir of await listDirs(dir)) {
-        for (const file of await listFiles(path14.join(dir, dateDir))) {
+        for (const file of await listFiles(path15.join(dir, dateDir))) {
           const match = TRACE_FILE_RE2.exec(file);
           if (match && !index.has(match[1])) index.set(match[1], agentId);
         }
@@ -7474,7 +7926,7 @@ var TraceService = class {
     const files = await this.locateAll(projectId, agentId, sessionId);
     const out = [];
     for (const file of files) {
-      const stat = await fs15.stat(file.path);
+      const stat = await fs16.stat(file.path);
       out.push({
         index: file.index,
         date: file.date,
@@ -7510,6 +7962,7 @@ var TraceService = class {
     let prevSerialTs = null;
     let taskIndex = -1;
     let continuation = false;
+    let steeringImages = false;
     let sawToolCallThisRequest = false;
     let compactionActive = false;
     const taskStats = /* @__PURE__ */ new Map();
@@ -7537,7 +7990,10 @@ var TraceService = class {
       const hasOrigin = msg.origin !== void 0 && msg.origin.length > 0;
       const isSteeringText = !hasOrigin && msg.type === "model_msg" && p.type === "text" && p.role === "user" && typeof p.text === "string" && parseUserSteeringText(p.text) !== null;
       if (isSteeringText) continuation = true;
-      const startsUserTurn = !hasOrigin && !compactionActive && !isSteeringText && msg.type === "model_msg" && (p.type === "text" && p.role === "user" || p.type === "image_url");
+      const isImage = !hasOrigin && msg.type === "model_msg" && p.type === "image_url";
+      if (!hasOrigin && !isSteeringText && !(isImage && steeringImages)) steeringImages = false;
+      if (isSteeringText) steeringImages = true;
+      const startsUserTurn = !hasOrigin && !compactionActive && !isSteeringText && !steeringImages && msg.type === "model_msg" && (p.type === "text" && p.role === "user" || p.type === "image_url");
       const startsCompactionTurn = !hasOrigin && msg.type === "event_msg" && p.type === "compaction_begin";
       if (startsUserTurn || startsCompactionTurn) {
         if (pendingFrom === null) pendingFrom = mi;
@@ -7582,7 +8038,7 @@ var TraceService = class {
           }
         } else if (p.type === "request_end") {
           const status = typeof p.status === "string" ? p.status : void 0;
-          const retryable = status === "timeout" || status === "malformed";
+          const retryable = status === "timeout" || status === "malformed" || status === "failed" && !compactionActive;
           if (!hasOrigin) {
             prevSerialTs = null;
             continuation = sawToolCallThisRequest || retryable;
@@ -7733,11 +8189,11 @@ var TraceService = class {
     const out = { dates: [] };
     for (const date of dates) {
       const bySession = /* @__PURE__ */ new Map();
-      for (const file of await listFiles(path14.join(dir, date))) {
+      for (const file of await listFiles(path15.join(dir, date))) {
         const match = TRACE_FILE_RE2.exec(file);
         if (!match) continue;
         const sessionId = match[1];
-        const stat = await fs15.stat(path14.join(dir, date, file));
+        const stat = await fs16.stat(path15.join(dir, date, file));
         const files = bySession.get(sessionId) ?? [];
         files.push({ index: Number(match[2]), sizeBytes: stat.size });
         bySession.set(sessionId, files);
@@ -7773,7 +8229,7 @@ var TraceService = class {
   /** Raw bytes of the Trace file at the given index (export/download: the file is served verbatim). */
   async readFileRaw(projectId, agentId, sessionId, index) {
     const file = await this.locateByIndex(projectId, agentId, sessionId, index);
-    return fs15.readFile(file.path);
+    return fs16.readFile(file.path);
   }
   /**
    * Imports an uploaded Trace file (raw JSONL content). Validates the content itself —
@@ -7812,11 +8268,11 @@ var TraceService = class {
     const ts = Date.parse(first.timestamp);
     const date = formatLocalDate(Number.isNaN(ts) ? /* @__PURE__ */ new Date() : new Date(ts));
     const index = 1;
-    const dir = path14.join(tracesDir3(this.root, projectId, agentId), date);
-    await fs15.mkdir(dir, { recursive: true });
-    const file = path14.join(dir, `${sessionId}_${String(index).padStart(3, "0")}.jsonl`);
+    const dir = path15.join(tracesDir3(this.root, projectId, agentId), date);
+    await fs16.mkdir(dir, { recursive: true });
+    const file = path15.join(dir, `${sessionId}_${String(index).padStart(3, "0")}.jsonl`);
     try {
-      await fs15.writeFile(file, content.replace(/\n+$/, "") + "\n", {
+      await fs16.writeFile(file, content.replace(/\n+$/, "") + "\n", {
         encoding: "utf8",
         flag: "wx"
       });
@@ -8015,6 +8471,33 @@ var UsageService = class {
       models: this.usage.distinctModels(projectId)
     };
   }
+  /**
+   * One page of the error detail table, newest first. The dashboard's own response already
+   * carries the first page (`errors.recent`); this serves the "show me earlier ones" paging,
+   * where refetching the whole aggregate to move one page would be wasteful. `total` is the
+   * filtered row count, so the caller knows when it has reached the end.
+   *
+   * Takes the same filter the dashboard applies — date + agent, and admin-only visibility of
+   * unattributed errors — so a page never widens what the summary above it counted.
+   *
+   * Paging is by offset into a newest-first table that grows at its head, so errors recorded
+   * between two page requests shift every row down and a page can re-show rows already seen.
+   * Accepted deliberately: this is a diagnostic table read at a moment in time, not a feed to
+   * be walked exhaustively, and keying off the newest row's id would cost a cursor the caller
+   * has no other use for.
+   */
+  queryErrors(projectId, q) {
+    const f = {
+      ...q.agentId !== void 0 ? { agentId: q.agentId } : {},
+      ...q.from !== void 0 ? { from: q.from } : {},
+      ...q.to !== void 0 ? { to: q.to } : {},
+      ...q.includeGlobalErrors === true ? { includeGlobal: true } : {}
+    };
+    return {
+      items: this.errors.recent(projectId, f, q.limit, q.offset),
+      total: this.errors.summary(projectId, f).total
+    };
+  }
   /** Error statistics: summary info (total / unexpected / most common error code) + the last N entries, all filtered by the selected range. */
   foldErrors(projectId, f) {
     const { total, unexpected } = this.errors.summary(projectId, f);
@@ -8167,7 +8650,7 @@ function buildAppDeps(config2, overrides = {}) {
   const traceService = new TraceService(config2.root);
   const workspaceFiles = new WorkspaceFilesService();
   const previewTokens = createPreviewTokenSigner();
-  const benchmarks = new BenchmarkService(config2.root);
+  const benchmarks = new BenchmarkService(config2.root, workspaceFiles);
   const snapshots = new SnapshotService(config2.root);
   const usageService = new UsageService(
     usageRepo,
@@ -8308,13 +8791,17 @@ function createApp(deps2) {
       await next();
     });
   }
-  app2.use("/api/*", async (c, next) => {
-    const contentLength = Number(c.req.header("content-length") ?? 0);
-    if (contentLength > MAX_BODY_BYTES) {
-      throw new HttpError(413, "payload_too_large", "Request body exceeds the 20MB limit.");
-    }
-    await next();
-  });
+  app2.use(
+    "/api/*",
+    bodyLimit({
+      maxSize: MAX_BODY_BYTES,
+      // Its default is a bare text/plain 413; throw the App's own error instead so the response
+      // stays the documented `payload_too_large` body that every client already handles.
+      onError: () => {
+        throw new HttpError(413, "payload_too_large", "Request body exceeds the 20MB limit.");
+      }
+    })
+  );
   app2.use("/api/*", jsonOnlyWrites);
   app2.route("/api/auth", authRoutes(deps2));
   const auth = authMiddleware(deps2.authService);
@@ -8340,7 +8827,7 @@ function createApp(deps2) {
   app2.route("/api/projects/:projectId/usage", usageRoutes(deps2));
   app2.route("/api/sessions", sessionsRoutes(deps2));
   app2.route("/preview", previewRoutes(deps2));
-  if (fs16.existsSync(deps2.config.webDist)) {
+  if (fs17.existsSync(deps2.config.webDist)) {
     registerStaticRoutes(app2, deps2.config.webDist);
   }
   return app2;
@@ -8376,16 +8863,16 @@ function registerStaticRoutes(app2, webDist) {
       return c.json(errorBody("not_found", "Endpoint does not exist."), 404);
     }
     const rel = reqPath.replace(/^\/+/, "");
-    const resolved = path15.resolve(webDist, rel === "" ? "index.html" : rel);
-    const base = path15.resolve(webDist);
-    const target = resolved === base || resolved.startsWith(base + path15.sep) ? resolved : path15.join(base, "index.html");
+    const resolved = path16.resolve(webDist, rel === "" ? "index.html" : rel);
+    const base = path16.resolve(webDist);
+    const target = resolved === base || resolved.startsWith(base + path16.sep) ? resolved : path16.join(base, "index.html");
     let file = target;
     try {
       const stat = await fsp.stat(file);
-      if (stat.isDirectory()) file = path15.join(file, "index.html");
+      if (stat.isDirectory()) file = path16.join(file, "index.html");
       await fsp.access(file);
     } catch {
-      file = path15.join(base, "index.html");
+      file = path16.join(base, "index.html");
     }
     let content;
     try {
@@ -8393,7 +8880,7 @@ function registerStaticRoutes(app2, webDist) {
     } catch {
       return c.json(errorBody("not_found", "Resource does not exist."), 404);
     }
-    const type = CONTENT_TYPES2[path15.extname(file).toLowerCase()] ?? "application/octet-stream";
+    const type = CONTENT_TYPES2[path16.extname(file).toLowerCase()] ?? "application/octet-stream";
     return new Response(new Uint8Array(content), {
       status: 200,
       headers: { "Content-Type": type }
@@ -8402,16 +8889,16 @@ function registerStaticRoutes(app2, webDist) {
 }
 
 // src/config.ts
-import fs17 from "fs";
-import path16 from "path";
+import fs18 from "fs";
+import path17 from "path";
 import { fileURLToPath } from "url";
 import { DEFAULT_SERVER_PORT, resolveRoot } from "@prismshadow/penguin-core";
 var DAY_MS = 24 * 60 * 60 * 1e3;
 function defaultWebDist() {
-  const here = path16.dirname(fileURLToPath(import.meta.url));
-  const bundled = path16.resolve(here, "..", "web-dist");
-  if (fs17.existsSync(bundled)) return bundled;
-  return path16.resolve(here, "..", "..", "web", "dist");
+  const here = path17.dirname(fileURLToPath(import.meta.url));
+  const bundled = path17.resolve(here, "..", "web-dist");
+  if (fs18.existsSync(bundled)) return bundled;
+  return path17.resolve(here, "..", "..", "web", "dist");
 }
 function normalizePreviewOrigin(raw) {
   if (!raw || raw.trim() === "") return null;
@@ -8436,7 +8923,7 @@ function resolveServerConfig(env = process.env) {
     root,
     host: env.HOST ?? "127.0.0.1",
     port,
-    dbPath: env.PENGUIN_WEB_DB ?? path16.join(root, "web.db"),
+    dbPath: env.PENGUIN_WEB_DB ?? path17.join(root, "web.db"),
     webDist: env.PENGUIN_WEB_DIST ?? defaultWebDist(),
     previewOrigin: normalizePreviewOrigin(env.PENGUIN_PREVIEW_ORIGIN),
     authSessionTtlMs: 7 * DAY_MS,