@prismshadow/penguin-server 0.1.2 → 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 { Hono as Hono20 } from "hono";
+import path16 from "path";
+import { Hono as Hono21 } from "hono";
+import { bodyLimit } from "hono/body-limit";
 
 // src/db/database.ts
 import { mkdirSync } from "fs";
@@ -102,6 +103,20 @@ CREATE TABLE IF NOT EXISTS schedule_state (    -- schedule runtime state (files
   invalid_reason  TEXT,                        -- invalidation reason (e.g. the bound Session was deleted); NULL=healthy
   PRIMARY KEY (project_id, agent_id, name)
 );
+CREATE TABLE IF NOT EXISTS goal_state (        -- goal-mode runtime state (GOAL.yaml on disk is the model-facing protocol; this row is what the UI reads)
+  id          INTEGER PRIMARY KEY AUTOINCREMENT,  -- one row per goal run; a Session may run goals repeatedly, latest row wins for display
+  session_id  TEXT NOT NULL,
+  project_id  TEXT NOT NULL,
+  agent_id    TEXT NOT NULL,
+  objective   TEXT NOT NULL,
+  status      TEXT NOT NULL,               -- active | complete | blocked | budget_limited | aborted (aborted is server-side only; on-disk status stays active)
+  budget      INTEGER NOT NULL,            -- token budget; -1 = unlimited
+  used        INTEGER NOT NULL DEFAULT 0,  -- uncached input + output, refreshed per round (mirrors the runner's accounting)
+  rounds      INTEGER NOT NULL DEFAULT 0,
+  created_at  TEXT NOT NULL,
+  updated_at  TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_goal_session ON goal_state(session_id);
 CREATE TABLE IF NOT EXISTS ui_prefs (
   user_id    TEXT PRIMARY KEY REFERENCES users(user_id) ON DELETE CASCADE,
   prefs_json TEXT NOT NULL                    -- {theme?, lastProjectId?, ...} free-form JSON
@@ -285,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,
@@ -300,6 +315,10 @@ var ErrorsRepo = class {
       message: r.message
     }));
   }
+  /** Cascading cleanup on Agent deletion (unattributed errors carry no agent_id and are unaffected). */
+  deleteByAgent(projectId, agentId) {
+    this.db.prepare("DELETE FROM error_records WHERE project_id = ? AND agent_id = ?").run(projectId, agentId);
+  }
   /** Cascading cleanup on Project deletion (unattributed errors belong to no Project and are unaffected). */
   deleteByProject(projectId) {
     this.db.prepare("DELETE FROM error_records WHERE project_id = ?").run(projectId);
@@ -385,8 +404,77 @@ var ProjectsRepo = class {
   }
 };
 
-// src/db/repos/schedules.ts
+// src/db/repos/goals.ts
 function mapRow2(r) {
+  return {
+    id: Number(r.id),
+    sessionId: r.session_id,
+    projectId: r.project_id,
+    agentId: r.agent_id,
+    objective: r.objective,
+    status: r.status,
+    budget: Number(r.budget),
+    used: Number(r.used),
+    rounds: Number(r.rounds),
+    createdAt: r.created_at,
+    updatedAt: r.updated_at
+  };
+}
+var GoalsRepo = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  /** Register a new goal run (status active, counters at zero); returns the new row id. */
+  create(args) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const result = this.db.prepare(
+      `INSERT INTO goal_state
+           (session_id, project_id, agent_id, objective, status, budget, used, rounds, created_at, updated_at)
+         VALUES (?, ?, ?, ?, 'active', ?, 0, 0, ?, ?)`
+    ).run(args.sessionId, args.projectId, args.agentId, args.objective, args.budget, now, now);
+    return Number(result.lastInsertRowid);
+  }
+  /** Per-round progress refresh (round just started; `used` mirrors the runner's accounting so far). */
+  progress(id, rounds, used) {
+    this.db.prepare("UPDATE goal_state SET rounds = ?, used = ?, updated_at = ? WHERE id = ?").run(rounds, used, (/* @__PURE__ */ new Date()).toISOString(), id);
+  }
+  /** Record the terminal outcome. */
+  finish(id, status, rounds, used) {
+    this.db.prepare(
+      "UPDATE goal_state SET status = ?, rounds = ?, used = ?, updated_at = ? WHERE id = ?"
+    ).run(status, rounds, used, (/* @__PURE__ */ new Date()).toISOString(), id);
+  }
+  /** The Session's most recent goal run (what the chat page's banner restores from); null if it never ran one. */
+  latestForSession(sessionId) {
+    const r = this.db.prepare("SELECT * FROM goal_state WHERE session_id = ? ORDER BY id DESC LIMIT 1").get(sessionId);
+    return r ? mapRow2(r) : null;
+  }
+  deleteBySession(sessionId) {
+    this.db.prepare("DELETE FROM goal_state WHERE session_id = ?").run(sessionId);
+  }
+  deleteByAgent(projectId, agentId) {
+    this.db.prepare("DELETE FROM goal_state WHERE project_id = ? AND agent_id = ?").run(projectId, agentId);
+  }
+  deleteByProject(projectId) {
+    this.db.prepare("DELETE FROM goal_state WHERE project_id = ?").run(projectId);
+  }
+  /**
+   * Startup reconciliation: a goal runs only in SessionManager memory, so a hard crash
+   * (SIGKILL, power loss) leaves its row stuck `active` with no runner behind it — the banner
+   * would then restore a forever-"running" goal. Called once at boot, before the server accepts
+   * connections (nothing can be running yet), so every remaining `active` row is an orphan:
+   * mark them `aborted`. The on-disk GOAL.yaml is left `active` as the documented resume point.
+   * Returns the number of rows reconciled.
+   */
+  abortOrphanedActive() {
+    const result = this.db.prepare("UPDATE goal_state SET status = 'aborted', updated_at = ? WHERE status = 'active'").run((/* @__PURE__ */ new Date()).toISOString());
+    return Number(result.changes);
+  }
+};
+
+// src/db/repos/schedules.ts
+function mapRow3(r) {
   return {
     projectId: r.project_id,
     agentId: r.agent_id,
@@ -408,11 +496,11 @@ var SchedulesRepo = class {
   db;
   find(projectId, agentId, name) {
     const r = this.db.prepare("SELECT * FROM schedule_state WHERE project_id = ? AND agent_id = ? AND name = ?").get(projectId, agentId, name);
-    return r ? mapRow2(r) : null;
+    return r ? mapRow3(r) : null;
   }
   listByAgent(projectId, agentId) {
     const rows = this.db.prepare("SELECT * FROM schedule_state WHERE project_id = ? AND agent_id = ? ORDER BY name").all(projectId, agentId);
-    return rows.map((r) => mapRow2(r));
+    return rows.map((r) => mapRow3(r));
   }
   /**
    * Register or sync a task's runtime state, returning the synced row plus a `fresh`
@@ -507,13 +595,16 @@ var SchedulesRepo = class {
     }
     return removed;
   }
+  deleteByAgent(projectId, agentId) {
+    this.db.prepare("DELETE FROM schedule_state WHERE project_id = ? AND agent_id = ?").run(projectId, agentId);
+  }
   deleteByProject(projectId) {
     this.db.prepare("DELETE FROM schedule_state WHERE project_id = ?").run(projectId);
   }
 };
 
 // src/db/repos/sessions.ts
-function mapRow3(r) {
+function mapRow4(r) {
   return {
     sessionId: r.session_id,
     projectId: r.project_id,
@@ -567,15 +658,15 @@ var SessionsRepo = class {
   }
   findById(sessionId) {
     const r = this.db.prepare("SELECT * FROM sessions WHERE session_id = ?").get(sessionId);
-    return r ? mapRow3(r) : null;
+    return r ? mapRow4(r) : null;
   }
   listByAgent(projectId, agentId) {
     const rows = this.db.prepare("SELECT * FROM sessions WHERE project_id = ? AND agent_id = ?").all(projectId, agentId);
-    return rows.map(mapRow3);
+    return rows.map(mapRow4);
   }
   listByProject(projectId) {
     const rows = this.db.prepare("SELECT * FROM sessions WHERE project_id = ?").all(projectId);
-    return rows.map(mapRow3);
+    return rows.map(mapRow4);
   }
   updateApprovalMode(sessionId, mode) {
     this.db.prepare("UPDATE sessions SET approval_mode = ? WHERE session_id = ?").run(mode, sessionId);
@@ -780,7 +871,7 @@ var UsageRepo = class {
 };
 
 // src/db/repos/users.ts
-function mapRow4(r) {
+function mapRow5(r) {
   return {
     userId: r.user_id,
     passwordHash: r.password_hash,
@@ -807,12 +898,12 @@ var UsersRepo = class {
   }
   findById(userId) {
     const r = this.db.prepare("SELECT * FROM users WHERE user_id = ?").get(userId);
-    return r ? mapRow4(r) : null;
+    return r ? mapRow5(r) : null;
   }
   /** All users (for the admin user backend), ordered by creation time ascending. */
   list() {
     const rows = this.db.prepare("SELECT * FROM users ORDER BY created_at ASC, user_id ASC").all();
-    return rows.map(mapRow4);
+    return rows.map(mapRow5);
   }
   count() {
     const r = this.db.prepare("SELECT COUNT(*) AS n FROM users").get();
@@ -1473,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);
@@ -1514,6 +1613,12 @@ function membersRoutes(deps2) {
 
 // src/http/routes/models.ts
 import { Hono as Hono7 } from "hono";
+function publishCredentialsUpdated(deps2, projectId) {
+  const event = { type: "credentials_updated" };
+  for (const row of deps2.sessionsRepo.listByProject(projectId)) {
+    deps2.channels.peek(row.sessionId)?.publish(event, "server_event");
+  }
+}
 function parseRef(value, label) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) {
     throw badRequest(`${label} must be a { provider, modelId } object.`);
@@ -1633,7 +1738,10 @@ function modelsRoutes(deps2) {
     const projectId = requireValidId(c, "projectId");
     deps2.projectService.requireProjectOwner(c.var.user.userId, projectId);
     const req = parseModelsUpdate(await readJson(c));
-    return c.json(await deps2.projectConfigService.updateModels(projectId, req));
+    const res = await deps2.projectConfigService.updateModels(projectId, req);
+    deps2.manager.invalidateProjectRuntimes(projectId);
+    publishCredentialsUpdated(deps2, projectId);
+    return c.json(res);
   });
   app2.post("/test", async (c) => {
     const projectId = requireValidId(c, "projectId");
@@ -2091,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) => {
@@ -2100,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;
 }
 
@@ -2305,6 +2466,9 @@ function agentsRoutes(deps2) {
       await settleWithin(runnings, 5e3);
       await deps2.agentService.deleteAgent(projectId, agentId);
       deps2.sessionsRepo.deleteByAgent(projectId, agentId);
+      deps2.goalsRepo.deleteByAgent(projectId, agentId);
+      deps2.schedulesRepo.deleteByAgent(projectId, agentId);
+      deps2.errorsRepo.deleteByAgent(projectId, agentId);
     } finally {
       deps2.manager.endAgentDeletion(projectId, agentId);
     }
@@ -2410,6 +2574,7 @@ function agentConfigRoutes(deps2) {
 
 // src/http/routes/agent-traces.ts
 import { Hono as Hono16 } from "hono";
+var MAX_TRACE_BYTES = 14 * 1024 * 1024;
 function agentTracesRoutes(deps2) {
   const app2 = new Hono16();
   app2.get("/", async (c) => {
@@ -2437,6 +2602,41 @@ function agentTracesRoutes(deps2) {
     const index = positiveIntParam(c, "index");
     return c.json(await deps2.traceService.analyze(projectId, agentId, sessionId, index));
   });
+  app2.get("/:sessionId/:index/download", async (c) => {
+    const projectId = requireValidId(c, "projectId");
+    const agentId = requireValidId(c, "agentId");
+    const sessionId = requireValidId(c, "sessionId");
+    deps2.projectService.requireProjectAccess(c.var.user.userId, projectId);
+    const index = positiveIntParam(c, "index");
+    const bytes = await deps2.traceService.readFileRaw(projectId, agentId, sessionId, index);
+    const fileName = `${sessionId}_${String(index).padStart(3, "0")}.jsonl`;
+    return new Response(new Uint8Array(bytes), {
+      headers: {
+        "Content-Type": "application/x-ndjson",
+        "Content-Disposition": `attachment; filename*=UTF-8''${encodeURIComponent(fileName)}`,
+        "X-Content-Type-Options": "nosniff"
+      }
+    });
+  });
+  app2.post("/import", async (c) => {
+    const projectId = requireValidId(c, "projectId");
+    const agentId = requireValidId(c, "agentId");
+    deps2.projectService.requireProjectOwner(c.var.user.userId, projectId);
+    await deps2.agentConfigService.requireExists(projectId, agentId);
+    const body = await readJson(c);
+    const dataBase64 = requireString(body, "dataBase64", { minLen: 1, maxLen: 20 * 1024 * 1024 });
+    const bytes = Buffer.from(dataBase64, "base64");
+    if (bytes.byteLength === 0) throw badRequest("Import file is empty.");
+    if (bytes.byteLength > MAX_TRACE_BYTES) {
+      throw badRequest("Import file exceeds the 14MB limit.");
+    }
+    const res = await deps2.traceService.importTraceFile(
+      projectId,
+      agentId,
+      bytes.toString("utf8")
+    );
+    return c.json(res);
+  });
   return app2;
 }
 
@@ -2473,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";
 
@@ -2658,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 });
@@ -2673,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 {
@@ -2708,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 } : {}
     };
   }
   /**
@@ -2735,6 +2977,10 @@ var WorkspaceFilesService = class {
     }
     const { dir, name } = await this.resolveWriteParent(workspace, rel);
     const file = path5.join(dir, name);
+    if (process.platform === "win32") {
+      const st = await fs6.lstat(file).catch(() => null);
+      if (st?.isSymbolicLink()) throw badRequest("path must not be a symlink.");
+    }
     const flags = fsc.O_WRONLY | fsc.O_CREAT | fsc.O_TRUNC | (fsc.O_NOFOLLOW ?? 0);
     let handle;
     try {
@@ -2755,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;
@@ -2772,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.`);
     }
@@ -2786,17 +3180,39 @@ 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;
+  if (goal === void 0) return null;
+  if (goal === null || typeof goal !== "object" || Array.isArray(goal)) {
+    throw badRequest("goal must be an object.");
+  }
+  const budget = goal.budget;
+  if (budget !== void 0 && (typeof budget !== "number" || !Number.isInteger(budget) || budget <= 0 && budget !== -1)) {
+    throw badRequest("goal.budget must be a positive integer, or -1 for unlimited.");
+  }
+  return { budget: budget ?? -1 };
 }
 function agentSessionsRoutes(deps2) {
   const app2 = new Hono18();
@@ -2947,11 +3363,12 @@ 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);
+      deps2.goalsRepo.deleteBySession(row.sessionId);
       deps2.sessionSources.delete(row.sessionId);
     } finally {
       deps2.manager.endSessionDeletion(row.sessionId);
@@ -2961,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.");
     }
@@ -2982,20 +3396,39 @@ 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"
     });
   });
   app2.get("/:sessionId/messages", async (c) => {
     const row = resolveSession(c);
+    let live;
+    if (deps2.manager.statusOf(row.sessionId) !== "idle") {
+      live = {
+        cursor: deps2.channels.get(row.sessionId).lastEventId,
+        fragments: deps2.manager.liveFragments(row.sessionId)
+      };
+    }
     const messages = await deps2.traceService.readMessages(
       row.projectId,
       row.agentId,
       row.sessionId
     );
-    return c.json({ messages });
+    return c.json({ messages, ...live !== void 0 ? { live } : {} });
   });
   app2.get("/:sessionId/stream", (c) => {
     const row = resolveSession(c);
@@ -3017,23 +3450,72 @@ function sessionsRoutes(deps2) {
   app2.post("/:sessionId/tasks", async (c) => {
     const row = resolveSession(c);
     const body = await readJson(c);
-    const input = parseTaskInput(body);
+    const goal = parseGoalField(body);
     const thinkingLevel = optionalEnum(body, "thinkingLevel", THINKING_LEVELS);
+    if (goal) {
+      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 } = await deps2.manager.startGoal(row.sessionId, {
+        input: messages,
+        budget: goal.budget,
+        ...thinkingLevel !== void 0 ? { thinkingLevel } : {}
+      });
+      return c.json({ sessionId }, 202);
+    }
+    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) => {
+    const row = resolveSession(c);
+    const g = deps2.goalsRepo.latestForSession(row.sessionId);
+    return c.json({
+      goal: g ? {
+        objective: g.objective,
+        status: g.status,
+        budget: g.budget,
+        used: g.used,
+        rounds: g.rounds,
+        updatedAt: g.updatedAt
+      } : null
+    });
+  });
   app2.post("/:sessionId/approvals/:toolCallId", async (c) => {
     const row = resolveSession(c);
     const body = await readJson(c);
@@ -3053,6 +3535,11 @@ function sessionsRoutes(deps2) {
     const aborted = deps2.manager.abortTask(row.sessionId);
     return c.body(null, aborted ? 202 : 204);
   });
+  app2.post("/:sessionId/retry-now", (c) => {
+    const row = resolveSession(c);
+    const skipped = deps2.manager.retryNow(row.sessionId);
+    return c.json({ skipped });
+  });
   app2.post("/:sessionId/compact", async (c) => {
     const row = resolveSession(c);
     const { sessionId } = await deps2.manager.startCompact(row.sessionId);
@@ -3167,6 +3654,104 @@ function sessionsRoutes(deps2) {
   return app2;
 }
 
+// src/http/routes/version.ts
+import { spawn } from "child_process";
+import { BUILD_DATE, VERSION } from "@prismshadow/penguin-core";
+import { Hono as Hono19 } from "hono";
+var OUTPUT_CAP = 64 * 1024;
+var UPDATE_TIMEOUT_MS = 10 * 60 * 1e3;
+var REFUSAL_MARKERS = [
+  "runs from a source checkout",
+  // sourceCheckout
+  "Cannot tell how this penguin was installed",
+  // unknownInstall
+  "could not be identified",
+  // npmUnknownManager
+  "does not run on Windows",
+  // windowsUnsupported
+  "cannot run your package manager for you"
+  // windowsGlobalInstall
+];
+function classifyUpdateRun(exitCode, output) {
+  if (exitCode !== 0) return { status: "failed", output, needsRestart: false };
+  if (REFUSAL_MARKERS.some((marker) => output.includes(marker))) {
+    return { status: "unsupported", output, needsRestart: false };
+  }
+  return { status: "updated", output, needsRestart: true };
+}
+function runSelfUpdate(cliEntry) {
+  return new Promise((resolve) => {
+    const child = spawn(process.execPath, [cliEntry, "update", "--yes"], {
+      env: { ...process.env, PENGUIN_LANG: "en" },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let output = "";
+    const append = (chunk) => {
+      output = (output + chunk.toString("utf8")).slice(-OUTPUT_CAP);
+    };
+    child.stdout.on("data", append);
+    child.stderr.on("data", append);
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+      setTimeout(() => child.kill("SIGKILL"), 1e4).unref();
+    }, UPDATE_TIMEOUT_MS);
+    timer.unref();
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      resolve({
+        status: "failed",
+        output: `${output}
+[failed to run the update command: ${err.message}]`.trim(),
+        needsRestart: false
+      });
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (timedOut) {
+        resolve({
+          status: "failed",
+          output: `${output}
+[the update run was killed after ${UPDATE_TIMEOUT_MS / 6e4} minutes]`.trim(),
+          needsRestart: false
+        });
+        return;
+      }
+      resolve(classifyUpdateRun(code ?? -1, output.trim()));
+    });
+  });
+}
+function versionRoutes(deps2) {
+  const app2 = new Hono19();
+  let inflightRun = null;
+  app2.get("/", (c) => {
+    return c.json({ version: VERSION, buildDate: BUILD_DATE });
+  });
+  app2.get("/update-check", async (c) => {
+    return c.json(await deps2.updateCheck.check(c.req.query("force") === "1"));
+  });
+  app2.post("/update", async (c) => {
+    if (!c.var.user.isAdmin) {
+      throw new HttpError(403, "admin_required", "Only an admin can perform this operation.");
+    }
+    const cliEntry = process.env.PENGUIN_CLI_ENTRY;
+    if (!cliEntry) {
+      return c.json({
+        status: "unsupported",
+        reason: "not_launched_via_cli",
+        output: "",
+        needsRestart: false
+      });
+    }
+    inflightRun ??= runSelfUpdate(cliEntry).finally(() => {
+      inflightRun = null;
+    });
+    return c.json(await inflightRun);
+  });
+  return app2;
+}
+
 // src/runtime/channel.ts
 import { randomUUID } from "crypto";
 var DEFAULT_MAX_COUNT = 1e4;
@@ -3191,6 +3776,16 @@ var Channel = class {
   get subscriberCount() {
     return this.listeners.size;
   }
+  /**
+   * Id of the most recently assigned event (`<epoch>-<seq>`; seq 0 when none was assigned
+   * yet). Unicast (sendTo) seqs count too — the value is a position marker, not a buffer
+   * lookup key. Used as the live-tail cursor on GET /messages: captured in the same
+   * synchronous tick as the fragment snapshot, it tells the client which buffered events
+   * the snapshot already covers.
+   */
+  get lastEventId() {
+    return `${this.epoch}-${this.nextSeq - 1}`;
+  }
   /** Broadcast an event: number it, buffer it (evicting the oldest), notify all subscribers. */
   publish(data, event) {
     const entry = this.makeEvent(data, event);
@@ -3358,12 +3953,16 @@ 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,
+  goalFinishedOf,
+  goalTokenDelta,
+  isGoalRoundInput,
   isSessionMeta as isSessionMeta2,
+  stripLeadingMarkerBlocks,
   tracesDir
 } from "@prismshadow/penguin-core";
 
@@ -3434,6 +4033,165 @@ function makeApprove(args) {
   };
 }
 
+// src/runtime/live-tail.ts
+import { isPartialPayload } from "@prismshadow/penguin-core";
+var FRAGMENT_CAP = 512 * 1024;
+var FRAGMENT_CAP_SLACK = 64 * 1024;
+function partialKindFor(p) {
+  switch (p.type) {
+    case "text":
+      return p.role === "assistant" ? "partial_text" : null;
+    case "thinking":
+      return "partial_thinking";
+    case "tool_call":
+      return "partial_tool_call";
+    case "tool_call_output":
+      return "partial_tool_call_output";
+    default:
+      return null;
+  }
+}
+function fragmentKey(origin, kind, toolCallId) {
+  return `${(origin ?? []).join("/")}\0${kind}::${toolCallId}`;
+}
+function toolCallIdOf(p) {
+  const id = p.tool_call_id;
+  return typeof id === "string" ? id : "";
+}
+function appendDelta(frag, p) {
+  switch (p.type) {
+    case "partial_text":
+      frag.buffer += p.text;
+      break;
+    case "partial_thinking":
+      frag.buffer += p.thinking;
+      break;
+    case "partial_tool_call":
+      frag.buffer += p.arguments;
+      if (p.name) frag.name = p.name;
+      frag.toolCallId = p.tool_call_id;
+      break;
+    case "partial_tool_call_output":
+      frag.buffer += p.output;
+      if (p.images && p.images.length > 0) frag.images = p.images;
+      frag.toolCallId = p.tool_call_id;
+      break;
+  }
+  if (frag.buffer.length > FRAGMENT_CAP + FRAGMENT_CAP_SLACK) {
+    frag.buffer = frag.buffer.slice(frag.buffer.length - FRAGMENT_CAP);
+  }
+}
+function startPayload(frag) {
+  switch (frag.kind) {
+    case "partial_text":
+      return { type: "partial_text", role: "assistant", event_type: "start", text: frag.buffer };
+    case "partial_thinking":
+      return {
+        type: "partial_thinking",
+        role: "assistant",
+        event_type: "start",
+        thinking: frag.buffer
+      };
+    case "partial_tool_call":
+      return {
+        type: "partial_tool_call",
+        role: "assistant",
+        event_type: "start",
+        name: frag.name ?? "",
+        arguments: frag.buffer,
+        tool_call_id: frag.toolCallId ?? ""
+      };
+    case "partial_tool_call_output":
+      return {
+        type: "partial_tool_call_output",
+        role: "user",
+        event_type: "start",
+        output: frag.buffer,
+        ...frag.images !== void 0 && frag.images.length > 0 ? { images: frag.images } : {},
+        tool_call_id: frag.toolCallId ?? ""
+      };
+  }
+}
+var LiveTailTracker = class {
+  /** sessionId → open fragments keyed by fragmentKey, in the order they were opened. */
+  sessions = /* @__PURE__ */ new Map();
+  /** Feed one published message (call in the same synchronous tick as the channel publish). */
+  observe(sessionId, msg) {
+    if (msg.type !== "model_msg") return;
+    const p = msg.payload;
+    if (!isPartialPayload(p)) {
+      const kind = partialKindFor(p);
+      if (kind === null) return;
+      const open3 = this.sessions.get(sessionId);
+      if (!open3) return;
+      open3.delete(fragmentKey(msg.origin, kind, toolCallIdOf(p)));
+      if (open3.size === 0) this.sessions.delete(sessionId);
+      return;
+    }
+    const key = fragmentKey(msg.origin, p.type, toolCallIdOf(p));
+    let open2 = this.sessions.get(sessionId);
+    if (p.event_type === "start") {
+      if (!open2) {
+        open2 = /* @__PURE__ */ new Map();
+        this.sessions.set(sessionId, open2);
+      }
+      const frag2 = {
+        kind: p.type,
+        timestamp: msg.timestamp,
+        buffer: "",
+        ...msg.origin && msg.origin.length > 0 ? { origin: [...msg.origin] } : {}
+      };
+      open2.delete(key);
+      open2.set(key, frag2);
+      appendDelta(frag2, p);
+      return;
+    }
+    let frag = open2?.get(key);
+    if (!frag) {
+      if (p.event_type === "stop") return;
+      if (!open2) {
+        open2 = /* @__PURE__ */ new Map();
+        this.sessions.set(sessionId, open2);
+      }
+      frag = {
+        kind: p.type,
+        timestamp: msg.timestamp,
+        buffer: "",
+        ...msg.origin && msg.origin.length > 0 ? { origin: [...msg.origin] } : {}
+      };
+      open2.set(key, frag);
+    }
+    appendDelta(frag, p);
+    if (p.event_type === "stop") {
+      open2.delete(key);
+      if (open2.size === 0) this.sessions.delete(sessionId);
+    }
+  }
+  /**
+   * Synthetic `partial_* start` messages for every open fragment (in open order), each
+   * carrying the full accumulated content, the original origin chain, and the original
+   * start timestamp. Empty when the session has no open fragments.
+   */
+  fragments(sessionId) {
+    const open2 = this.sessions.get(sessionId);
+    if (!open2) return [];
+    const out = [];
+    for (const frag of open2.values()) {
+      out.push({
+        timestamp: frag.timestamp,
+        type: "model_msg",
+        payload: startPayload(frag),
+        ...frag.origin !== void 0 ? { origin: [...frag.origin] } : {}
+      });
+    }
+    return out;
+  }
+  /** Drop all fragment state for a session (the run ended; nothing will continue these fragments). */
+  clear(sessionId) {
+    this.sessions.delete(sessionId);
+  }
+};
+
 // src/runtime/session-sources.ts
 function asSessionSource(v) {
   return v === "schedule" || v === "subagent" ? v : void 0;
@@ -3456,11 +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)." },
+  // 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",
@@ -3472,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";
+  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);
 }
@@ -3497,7 +4281,7 @@ var StreamErrorWatcher = class {
   }
   errors;
   ctx;
-  /** LLM failures awaiting a real reason: origin → failure state (see file header; each session has at most one in-flight Request). */
+  /** LLM failures awaiting a real reason: origin → failure state + the request_end's own detail (see file header; each session has at most one in-flight Request). */
   pending = /* @__PURE__ */ new Map();
   /** Names of in-flight tool calls: `origin \0 tool_call_id` → tool name (dequeued once output arrives). */
   toolNames = /* @__PURE__ */ new Map();
@@ -3535,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 });
@@ -3561,11 +4345,18 @@ var StreamErrorWatcher = class {
     const key = originKey(msg);
     if (p.type === "request_end") {
       this.flush(key);
-      if (isLlmFailure(p.status)) this.pending.set(key, p.status);
+      if (isLlmFailure(p.status)) {
+        this.pending.set(key, {
+          status: p.status,
+          // The event's own failure detail (LLMOutcome.message): the message of record when
+          // no abort follows (the retry path).
+          ...typeof p.message === "string" && p.message.trim() ? { message: p.message } : {}
+        });
+      }
       return;
     }
     if (p.type === "request_begin") {
-      this.flush(key);
+      this.flush(key, null, true);
       return;
     }
     if (p.type === "abort") {
@@ -3574,17 +4365,23 @@ 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) {
-    const status = this.pending.get(key);
-    if (status === void 0) return;
+  flush(key, reason, retried = false) {
+    const entry = this.pending.get(key);
+    if (entry === void 0) return;
     this.pending.delete(key);
-    const spec = LLM_FAILURES[status];
+    const spec = retried && entry.status === "failed" ? LLM_FAILED_RETRIED : LLM_FAILURES[entry.status];
     const trimmed = reason?.trim();
-    const message = trimmed && !isUserAbortReason(trimmed) ? trimmed : spec.text;
+    const message = trimmed && !isUserAbortReason(trimmed) ? trimmed : entry.message ?? spec.text;
     this.errors.record({
       source: "llm",
       err: message,
@@ -3612,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"}`,
@@ -3653,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(
@@ -3748,6 +4547,8 @@ var SessionManager = class {
   deletingSessions = /* @__PURE__ */ new Set();
   /** Per-Agent config generation (key = agentKey), bumped by invalidateAgentRuntimes on vault updates. */
   agentGenerations = /* @__PURE__ */ new Map();
+  /** Open streaming fragments of running sessions (fed by drive, served to GET /messages; see live-tail.ts). */
+  liveTail = new LiveTailTracker();
   sweepTimer;
   // —— Query surface (used by Session listing / Agent active-count / SSE subscription replay) ——
   statusOf(sessionId) {
@@ -3763,6 +4564,15 @@ var SessionManager = class {
   pendingFollowUpCount(sessionId) {
     return this.entries.get(sessionId)?.followUps.length ?? 0;
   }
+  /**
+   * Live tail of a running session: one synthetic `partial_* start` OmniMessage per open
+   * streaming fragment, carrying the full accumulated content so far (see live-tail.ts).
+   * Empty when idle or when nothing is streaming. GET /messages attaches this (with a
+   * channel cursor) so a client joining mid-stream can render the in-progress message.
+   */
+  liveFragments(sessionId) {
+    return this.liveTail.fragments(sessionId);
+  }
   /** Number of Sessions for this Agent that are currently running / compacting. */
   activeCountForAgent(projectId, agentId) {
     let n = 0;
@@ -3802,7 +4612,39 @@ var SessionManager = class {
     const key = agentKey(projectId, agentId);
     this.agentGenerations.set(key, this.generationOf(projectId, agentId) + 1);
   }
+  /**
+   * After a Project's models/credentials change: invalidate every cached runtime in this
+   * Project, so the next Task re-resumes with the new api_key / base_url. Same
+   * effective-value semantics as invalidateAgentRuntimes — no hot swap into a Task already
+   * in flight. Iterating the active table is complete here, not a shortcut: the generation
+   * map only matters for runtimes that are already cached, and an Agent with no cached
+   * entry builds fresh through the loader anyway.
+   */
+  invalidateProjectRuntimes(projectId) {
+    const agentIds = /* @__PURE__ */ new Set();
+    for (const e of this.entries.values()) {
+      if (e.projectId === projectId) agentIds.add(e.agentId);
+    }
+    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
@@ -3834,6 +4676,135 @@ var SessionManager = class {
       return { sessionId: entry.sessionId, queued: false };
     });
   }
+  /**
+   * Start a goal run: like startTask, but the run is core goal mode — one
+   * `session.run(input, { goal })` call loops rounds until a terminal state, and the
+   * Session stays `running` for the whole goal (every round), so the existing abort
+   * endpoint interrupts the entire loop and schedules queue behind it as usual. Round
+   * inputs are yielded by core and published like any streamed message; progress
+   * additionally goes out as goal_* server events and into goal_state (when a repo is
+   * wired).
+   */
+  async startGoal(sessionId, args) {
+    return this.withLock(sessionId, async () => {
+      this.assertOpen();
+      this.assertAgentNotDeleting(sessionId);
+      this.assertSessionNotDeleting(sessionId);
+      const entry = await this.ensureEntry(sessionId);
+      this.assertIdle(entry);
+      const text = args.input.filter(isPlainText("user")).map((m) => m.payload.text).join("\n");
+      const objective = stripLeadingMarkerBlocks(text).trim() || text.trim();
+      const ac = new AbortController();
+      entry.status = "running";
+      entry.abort = ac;
+      entry.lastActivityMs = Date.now();
+      this.publishState(entry, "running");
+      const approve = makeApprove({
+        getMode: () => this.deps.sessions.findById(entry.sessionId)?.approvalMode ?? "always-ask",
+        toolPermission: (name) => entry.session.toolPermission(name),
+        registry: entry.approvals,
+        publishRequest: (pending) => this.publishEvent(entry, {
+          type: "approval_request",
+          toolCall: pending.toolCall,
+          ...pending.origin !== void 0 ? { origin: pending.origin } : {}
+        })
+      });
+      const goalId = this.deps.goals?.create({
+        sessionId: entry.sessionId,
+        projectId: entry.projectId,
+        agentId: entry.agentId,
+        objective,
+        budget: args.budget
+      });
+      this.publishEvent(entry, {
+        type: "goal_started",
+        sessionId: entry.sessionId,
+        objective,
+        budget: args.budget
+      });
+      const gen = this.goalStream(entry, {
+        input: args.input,
+        budget: args.budget,
+        ...args.thinkingLevel !== void 0 ? { thinkingLevel: args.thinkingLevel } : {},
+        approve,
+        signal: ac.signal,
+        ...goalId !== void 0 ? { goalId } : {}
+      });
+      entry.running = this.drive(entry, gen, { userExcerpt: objective });
+      return { sessionId: entry.sessionId };
+    });
+  }
+  /**
+   * Taps core's goal-mode stream for `drive`: round boundaries (the injected `[goal]`
+   * inputs) become goal_round events + goal_state refreshes, and the terminal
+   * `goal_finished` event message becomes the goal_finished server event + the run-state
+   * row's final status. Token numbers mirror core's own accounting (same
+   * `goalTokenDelta`), so the UI shows exactly what the budget check uses.
+   */
+  async *goalStream(entry, args) {
+    const gen = entry.session.run(args.input, {
+      approve: args.approve,
+      signal: args.signal,
+      ...args.thinkingLevel !== void 0 ? { thinkingLevel: args.thinkingLevel } : {},
+      goal: { budget: args.budget }
+    });
+    let round = 0;
+    let used = 0;
+    let finished = false;
+    try {
+      for await (const msg of gen) {
+        used += goalTokenDelta(msg);
+        if (isGoalRoundInput(msg)) {
+          round++;
+          if (args.goalId !== void 0) this.deps.goals?.progress(args.goalId, round, used);
+          this.publishEvent(entry, {
+            type: "goal_round",
+            sessionId: entry.sessionId,
+            round,
+            used,
+            budget: args.budget
+          });
+        }
+        const outcome = goalFinishedOf(msg);
+        if (outcome) {
+          finished = true;
+          if (args.goalId !== void 0) {
+            this.deps.goals?.finish(
+              args.goalId,
+              outcome.outcome,
+              outcome.rounds,
+              outcome.tokensUsed
+            );
+          }
+          this.publishEvent(entry, {
+            type: "goal_finished",
+            sessionId: entry.sessionId,
+            outcome: outcome.outcome,
+            rounds: outcome.rounds,
+            used: outcome.tokensUsed
+          });
+        }
+        yield msg;
+      }
+      if (!finished) {
+        this.finishAborted(entry, args.goalId, round, used);
+      }
+    } catch (err) {
+      if (!finished) this.finishAborted(entry, args.goalId, round, used);
+      throw err;
+    }
+  }
+  /** Closes a goal's run state as aborted (stream cut off / infrastructure failure). */
+  finishAborted(entry, goalId, round, used) {
+    if (goalId !== void 0) this.deps.goals?.finish(goalId, "aborted", round, used);
+    this.publishEvent(entry, {
+      type: "goal_finished",
+      sessionId: entry.sessionId,
+      outcome: "aborted",
+      rounds: round,
+      used
+    });
+  }
   /** Shared task launch (fresh tasks and auto-started follow-ups): flips to running, publishes the input, and drives the run with the per-turn thinking level (if any). Caller holds the session lock and has verified idle. */
   launchTask(entry, input, thinkingLevel) {
     const channel = this.deps.channels.get(entry.sessionId);
@@ -3912,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",
@@ -3929,6 +4901,21 @@ var SessionManager = class {
     }
     entry.lastActivityMs = Date.now();
   }
+  /**
+   * "Retry now" on the reconnect countdown: skip the in-progress backoff wait and fire
+   * the next retry immediately (the attempt counter is unchanged — the skipped wait does
+   * not consume an extra attempt). Returns false as a benign no-op when the session has
+   * no active runtime or no reconnect wait is in progress — timing races (the wait
+   * elapsed right before the click) must not surface as errors. Mirrors the steer seam:
+   * manager → RuntimeSession → core Session → engine.
+   */
+  retryNow(sessionId) {
+    const entry = this.entries.get(sessionId);
+    if (!entry || entry.status === "idle") return false;
+    const skipped = entry.session.skipReconnectWait();
+    if (skipped) entry.lastActivityMs = Date.now();
+    return skipped;
+  }
   /**
    * Interrupt the current Task/compaction: pending approvals converge to deny first,
    * then the AbortSignal fires. Returns false if nothing is in progress (the route
@@ -4204,6 +5191,7 @@ var SessionManager = class {
             }
           }
         }
+        this.liveTail.observe(entry.sessionId, msg);
         this.deps.channels.get(entry.sessionId).publish(msg);
         watcher?.observe(msg);
         try {
@@ -4220,6 +5208,7 @@ var SessionManager = class {
       this.deps.errors?.record({ source: "session", err, ctx, code: "session_run_failed" });
     } finally {
       watcher?.close();
+      this.liveTail.clear(entry.sessionId);
       entry.approvals.denyAll();
       entry.status = "idle";
       entry.abort = null;
@@ -4267,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);
@@ -4746,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_]+$/;
@@ -4822,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,
@@ -4837,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,
@@ -4890,11 +5879,24 @@ var ProjectConfigService = class {
   filePath(projectId) {
     return projectConfigPath(this.root, projectId);
   }
+  /**
+   * When the Project config (models/credentials) last changed: the config file's mtime as
+   * ISO — an honest persistent source that survives server restarts (every models update
+   * rewrites the file). undefined when the file doesn't exist yet.
+   */
+  async configUpdatedAt(projectId) {
+    try {
+      const st = await fs10.stat(this.filePath(projectId));
+      return st.mtime.toISOString();
+    } catch {
+      return void 0;
+    }
+  }
   /** Reads the raw TOML object; returns an empty object if the file doesn't exist (does not write to disk). */
   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;
@@ -4909,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
@@ -4955,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);
@@ -5107,9 +6118,11 @@ var ProjectConfigService = class {
       provider: ref.provider,
       modelId: ref.model_id
     });
+    const updatedAt = await this.configUpdatedAt(projectId);
     return {
       ...defaultRef !== void 0 ? { defaultModel: toDto(defaultRef) } : {},
       ...visionRef !== void 0 ? { visionModel: toDto(visionRef) } : {},
+      ...updatedAt !== void 0 ? { updatedAt } : {},
       models
     };
   }
@@ -5273,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;
@@ -5291,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;
@@ -5309,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 = {
@@ -5359,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");
     }
   }
   /**
@@ -5377,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(
@@ -5428,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) {
@@ -5525,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,
@@ -5553,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 {
     }
@@ -5562,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;
@@ -5606,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;
@@ -5617,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;
@@ -5642,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;
         }
@@ -5667,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);
   }
   /**
@@ -5684,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
     );
@@ -5698,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;
     }
@@ -5722,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 !== "") {
@@ -5850,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);
@@ -5859,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 {
@@ -5875,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 {
@@ -5890,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) {
@@ -5901,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.");
     }
@@ -5914,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,
@@ -5932,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. */
@@ -5949,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,
@@ -5965,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.");
       }
@@ -5991,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;
@@ -6146,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;
     }
@@ -6184,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
@@ -6231,7 +7346,8 @@ var ProjectService = class {
     this.deps.usage.deleteByProject(projectId);
     this.deps.errors.deleteByProject(projectId);
     this.deps.schedules.deleteByProject(projectId);
-    await fs14.rm(projectDir(this.deps.root, projectId), { recursive: true, force: true });
+    this.deps.goals.deleteByProject(projectId);
+    await fs15.rm(projectDir(this.deps.root, projectId), { recursive: true, force: true });
   }
   // —— Member authorization ——
   /** Member list: owner (role=owner) + members. */
@@ -6302,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,
@@ -6484,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]);
       }
@@ -6600,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 });
         }
       }
     }
@@ -6670,15 +7786,18 @@ 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,
+  parseTraceLines as parseTraceLines2,
   parseUserSteeringText,
   readTraceTolerant as readTraceTolerant2,
   tracesDir as tracesDir3
 } from "@prismshadow/penguin-core";
 var TRACE_FILE_RE2 = /^(.+)_(\d{3})\.jsonl$/;
+var IMPORT_SESSION_ID_RE = /^[A-Za-z0-9_-]{1,128}$/;
 var MAX_SUBAGENT_DEPTH = 4;
 function subagentPointer(msg) {
   if (msg.type !== "event_msg") return null;
@@ -6690,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 [];
@@ -6698,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 [];
@@ -6714,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);
@@ -6726,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 });
     }
   }
   /**
@@ -6764,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);
         }
@@ -6807,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,
@@ -6843,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();
@@ -6870,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;
@@ -6915,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;
@@ -7066,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);
@@ -7088,6 +8211,10 @@ var TraceService = class {
     return out;
   }
   async readFileByIndex(projectId, agentId, sessionId, index) {
+    const file = await this.locateByIndex(projectId, agentId, sessionId, index);
+    return readTraceTolerant2(file.path);
+  }
+  async locateByIndex(projectId, agentId, sessionId, index) {
     const files = await this.locateAll(projectId, agentId, sessionId);
     const file = files.find((f) => f.index === index);
     if (!file) {
@@ -7097,7 +8224,165 @@ var TraceService = class {
         `This Session has no Trace file with index ${index}.`
       );
     }
-    return readTraceTolerant2(file.path);
+    return file;
+  }
+  /** 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 fs16.readFile(file.path);
+  }
+  /**
+   * Imports an uploaded Trace file (raw JSONL content). Validates the content itself —
+   * parseable JSONL whose first record is a `session_meta` carrying a filename-safe
+   * `session_id` (400 invalid_trace otherwise) — then writes it under the Agent's traces
+   * directory as a **new Session**: a session id the Agent already has is rejected with
+   * 409 `trace_session_exists` (splicing a further index into an existing Session would
+   * corrupt its concatenated transcript, silently become its resume point, and could
+   * collide with a live Writer's rotation), so the imported file is always index 1. The
+   * date dir comes from the first record's timestamp (falling back to now), formatted as
+   * a **local** date — the same convention as core's Trace Writer — so an export →
+   * import round-trip lands in the same date dir on non-UTC servers.
+   */
+  async importTraceFile(projectId, agentId, content) {
+    const invalid = (message) => new HttpError(400, "invalid_trace", message);
+    let records;
+    try {
+      records = parseTraceLines2(content);
+    } catch {
+      throw invalid("The file is not valid Trace JSONL.");
+    }
+    if (records.length === 0) throw invalid("The file contains no Trace records.");
+    const first = records[0];
+    if (!isSessionMeta5(first))
+      throw invalid("The first record of a Trace file must be session_meta.");
+    const sessionId = first.payload.session_id;
+    if (typeof sessionId !== "string" || !IMPORT_SESSION_ID_RE.test(sessionId)) {
+      throw invalid("session_meta carries a missing or invalid session_id.");
+    }
+    const duplicate = () => new HttpError(
+      409,
+      "trace_session_exists",
+      `This Agent already has a Session with id ${sessionId}; a duplicate Trace cannot be imported.`
+    );
+    if ((await this.locateAll(projectId, agentId, sessionId)).length > 0) throw duplicate();
+    const ts = Date.parse(first.timestamp);
+    const date = formatLocalDate(Number.isNaN(ts) ? /* @__PURE__ */ new Date() : new Date(ts));
+    const index = 1;
+    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 fs16.writeFile(file, content.replace(/\n+$/, "") + "\n", {
+        encoding: "utf8",
+        flag: "wx"
+      });
+    } catch (err) {
+      if (err.code === "EEXIST") throw duplicate();
+      throw err;
+    }
+    return { sessionId, index, date };
+  }
+};
+
+// src/services/update-check-service.ts
+import { BUILD_DATE as BUILD_DATE2, VERSION as VERSION2, compareVersions, normalizeVersion } from "@prismshadow/penguin-core";
+var REPO_SLUG = "Prism-Shadow/penguin-harness";
+var LATEST_RELEASE_API = `https://api.github.com/repos/${REPO_SLUG}/releases/latest`;
+var SUCCESS_TTL_MS = 60 * 60 * 1e3;
+var FAILURE_TTL_MS = 10 * 60 * 1e3;
+var UpdateCheckService = class {
+  fetchImpl;
+  now;
+  env;
+  cached = null;
+  inflight = null;
+  constructor(options = {}) {
+    this.fetchImpl = options.fetchImpl ?? fetch;
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+    this.env = options.env ?? process.env;
+  }
+  /**
+   * Never throws; never makes a network call when disabled or (without `force`) while
+   * the cache is fresh. `force` — the web's manual "check for updates" action — skips
+   * the freshness check and performs a real lookup even over a warm cache: the cache
+   * exists to shield GitHub's unauthenticated rate limit from *passive* checks fired
+   * by every sidebar open, and an explicit user click is rare enough to press through
+   * it. Everything else is unchanged: the opt-out stays authoritative (force never
+   * dials out under PENGUIN_UPDATE_CHECK=off), the outcome lands in the same cache
+   * (subsequent passive checks reuse it), and concurrent callers — forced or not —
+   * still share one in-flight lookup.
+   */
+  async check(force = false) {
+    if (this.env["PENGUIN_UPDATE_CHECK"] === "off") {
+      return {
+        currentVersion: VERSION2,
+        buildDate: BUILD_DATE2,
+        latestVersion: null,
+        updateAvailable: false,
+        releaseUrl: null,
+        publishedAt: null,
+        checkedAt: this.now().toISOString(),
+        disabled: true
+      };
+    }
+    if (!force && this.cached && this.now().getTime() < this.cached.expiresAt) {
+      return this.cached.response;
+    }
+    this.inflight ??= this.lookup().finally(() => {
+      this.inflight = null;
+    });
+    return this.inflight;
+  }
+  /** One real lookup; stores the outcome (success or failure) in the cache with its TTL. */
+  async lookup() {
+    const response = await this.resolveLatest();
+    const ttl = response.error === void 0 ? SUCCESS_TTL_MS : FAILURE_TTL_MS;
+    this.cached = { response, expiresAt: this.now().getTime() + ttl };
+    return response;
+  }
+  /**
+   * Failure taxonomy mirrors the CLI's fetchLatestVersion: an unreachable endpoint or
+   * timeout is "network"; a 403/429 is "rate_limited" (unauthenticated clients hit
+   * GitHub's per-IP limit); any other non-2xx status, an unparsable body, or a body
+   * without a usable tag_name is "bad_response".
+   */
+  async resolveLatest() {
+    const checkedAt = this.now().toISOString();
+    const base = { currentVersion: VERSION2, buildDate: BUILD_DATE2, checkedAt };
+    const failure = (error) => ({
+      ...base,
+      latestVersion: null,
+      updateAvailable: false,
+      releaseUrl: null,
+      publishedAt: null,
+      error
+    });
+    let res;
+    try {
+      res = await this.fetchImpl(LATEST_RELEASE_API, {
+        headers: { accept: "application/vnd.github+json", "user-agent": "penguin-server" },
+        signal: AbortSignal.timeout(15e3)
+      });
+    } catch {
+      return failure("network");
+    }
+    if (res.status === 403 || res.status === 429) return failure("rate_limited");
+    if (!res.ok) return failure("bad_response");
+    let body;
+    try {
+      body = await res.json();
+    } catch {
+      return failure("bad_response");
+    }
+    const tag = typeof body.tag_name === "string" ? normalizeVersion(body.tag_name) : "";
+    if (tag === "") return failure("bad_response");
+    return {
+      ...base,
+      latestVersion: tag,
+      updateAvailable: compareVersions(tag, VERSION2) > 0,
+      releaseUrl: typeof body.html_url === "string" ? body.html_url : null,
+      publishedAt: typeof body.published_at === "string" ? body.published_at : null
+    };
   }
 };
 
@@ -7186,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);
@@ -7270,10 +8582,10 @@ var UsageService = class {
 };
 
 // src/http/routes/preview.ts
-import { Hono as Hono19 } from "hono";
+import { Hono as Hono20 } from "hono";
 var DIRECTORY_INDEX = "index.html";
 function previewRoutes(deps2) {
-  const app2 = new Hono19();
+  const app2 = new Hono20();
   app2.get("/:token/*", async (c) => {
     const token = c.req.param("token");
     const payload = token ? deps2.previewTokens.verify(token) : null;
@@ -7331,13 +8643,14 @@ function buildAppDeps(config2, overrides = {}) {
   const errorsRepo = new ErrorsRepo(db);
   const prefsRepo = new UiPrefsRepo(db);
   const schedulesRepo = new SchedulesRepo(db);
+  const goalsRepo = new GoalsRepo(db);
   const projectConfigService = new ProjectConfigService(config2.root);
   const agentConfigService = new AgentConfigService(config2.root);
   const agentService = new AgentService(config2.root, agentsRepo, agentConfigService);
   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,
@@ -7345,6 +8658,7 @@ function buildAppDeps(config2, overrides = {}) {
     (projectId, provider, modelId) => projectConfigService.getPricing(projectId, provider, modelId),
     overrides.now ?? (() => /* @__PURE__ */ new Date())
   );
+  const updateCheck = overrides.updateCheck ?? new UpdateCheckService(overrides.now ? { now: overrides.now } : {});
   let managerRef;
   const channels = new ChannelHub({
     isActive: (key) => managerRef !== void 0 && managerRef.statusOf(key) !== "idle"
@@ -7361,7 +8675,8 @@ function buildAppDeps(config2, overrides = {}) {
     recorder,
     errors,
     titles,
-    log
+    log,
+    goals: goalsRepo
   });
   managerRef = manager;
   const projectService = new ProjectService({
@@ -7374,6 +8689,7 @@ function buildAppDeps(config2, overrides = {}) {
     usage: usageRepo,
     errors: errorsRepo,
     schedules: schedulesRepo,
+    goals: goalsRepo,
     projectConfig: projectConfigService,
     manager
   });
@@ -7426,11 +8742,14 @@ function buildAppDeps(config2, overrides = {}) {
     sessionService,
     traceService,
     usageService,
+    updateCheck,
     workspaceFiles,
     previewTokens,
     benchmarks,
     snapshots,
     schedulesRepo,
+    goalsRepo,
+    errorsRepo,
     scheduler,
     channels,
     manager,
@@ -7440,7 +8759,7 @@ function buildAppDeps(config2, overrides = {}) {
   };
 }
 function createApp(deps2) {
-  const app2 = new Hono20();
+  const app2 = new Hono21();
   app2.onError((err, c) => {
     const projectId = attributedProjectId(c, deps2);
     deps2.errors.record({
@@ -7472,18 +8791,23 @@ 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);
   app2.use("/api/*", auth);
   app2.route("/api/me", meRoutes(deps2));
+  app2.route("/api/version", versionRoutes(deps2));
   app2.route("/api/admin/users", adminUsersRoutes(deps2));
   app2.route("/api/events", eventsRoutes(deps2));
   app2.route("/api/skills", skillLibraryRoutes());
@@ -7503,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;
@@ -7539,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 {
@@ -7556,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 }
@@ -7565,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;
@@ -7599,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,
@@ -7614,6 +8938,7 @@ var deps = buildAppDeps(config);
 var app = createApp(deps);
 await deps.authService.seedAdmin();
 await deps.scheduler.start();
+deps.goalsRepo.abortOrphanedActive();
 var appHost = loopbackHostRoles(config.host)?.app ?? config.host;
 var server = serve({ fetch: app.fetch, hostname: config.host, port: config.port }, (info) => {
   console.log(`penguin-server started: http://${appHost}:${info.port}`);