@prismshadow/penguin-server 0.1.1 → 0.1.4

package/dist/index.js

@@ -6,7 +6,7 @@ import { serve } from "@hono/node-server";
 import fs16 from "fs";
 import fsp from "fs/promises";
 import path15 from "path";
-import { Hono as Hono19 } from "hono";
+import { Hono as Hono21 } from "hono";
 
 // src/db/database.ts
 import { mkdirSync } from "fs";
@@ -102,6 +102,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
@@ -300,6 +314,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 +403,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 +495,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 +594,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 +657,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 +870,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 +897,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();
@@ -1154,6 +1244,12 @@ function optionalNumber(obj, key, rule = {}) {
   if (rule.nonNegative && v < 0) throw badRequest(`${label} must not be negative.`);
   return v;
 }
+function optionalBoolean(obj, key, label = key) {
+  const v = obj[key];
+  if (v === void 0) return void 0;
+  if (typeof v !== "boolean") throw badRequest(`${label} must be a boolean.`);
+  return v;
+}
 function optionalDateParam(value, label) {
   if (value === void 0 || value === "") return void 0;
   const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
@@ -1233,10 +1329,111 @@ function authRoutes(deps2) {
 
 // src/http/routes/me.ts
 import { Hono as Hono3 } from "hono";
+
+// src/services/preview-token.ts
+import { createHmac, randomBytes as randomBytes3, timingSafeEqual as timingSafeEqual2 } from "crypto";
+var PREVIEW_TOKEN_TTL_MS = 10 * 60 * 1e3;
+function b64url(buf) {
+  return buf.toString("base64url");
+}
+function createPreviewTokenSigner(secret = randomBytes3(32)) {
+  const mac = (body) => createHmac("sha256", secret).update(body).digest();
+  return {
+    sign(payload) {
+      const body = b64url(Buffer.from(JSON.stringify(payload), "utf8"));
+      return `${body}.${b64url(mac(body))}`;
+    },
+    verify(token) {
+      const dot = token.indexOf(".");
+      if (dot <= 0 || dot === token.length - 1) return null;
+      const body = token.slice(0, dot);
+      const provided = Buffer.from(token.slice(dot + 1), "base64url");
+      const expected = mac(body);
+      if (provided.length !== expected.length || !timingSafeEqual2(provided, expected)) return null;
+      let payload;
+      try {
+        payload = JSON.parse(
+          Buffer.from(body, "base64url").toString("utf8")
+        );
+      } catch {
+        return null;
+      }
+      if (typeof payload?.sessionId !== "string" || typeof payload?.host !== "string" || typeof payload?.expiresAt !== "number") {
+        return null;
+      }
+      if (Date.now() >= payload.expiresAt) return null;
+      return payload;
+    }
+  };
+}
+function hostOnly(hostHeader) {
+  const trimmed = hostHeader.trim();
+  if (trimmed.startsWith("[")) {
+    const end = trimmed.indexOf("]");
+    return end === -1 ? trimmed : trimmed.slice(0, end + 1);
+  }
+  const colon = trimmed.lastIndexOf(":");
+  return colon === -1 ? trimmed : trimmed.slice(0, colon);
+}
+function loopbackCounterpart(host) {
+  const h = host.toLowerCase();
+  if (h === "127.0.0.1") return "localhost";
+  if (h === "localhost") return "127.0.0.1";
+  if (h === "[::1]") return "127.0.0.1";
+  return null;
+}
+function loopbackHostRoles(bindHost) {
+  const h = bindHost.trim().toLowerCase();
+  if (h !== "127.0.0.1" && h !== "localhost") return null;
+  const app2 = "localhost";
+  const preview = loopbackCounterpart(app2);
+  if (!preview) return null;
+  return { app: app2, preview };
+}
+function requestAuthority(requestUrl, hostHeader) {
+  const header = (hostHeader ?? "").trim();
+  if (header !== "") return header;
+  try {
+    return new URL(requestUrl).host;
+  } catch {
+    return "";
+  }
+}
+function resolvePreviewTarget(requestUrl, hostHeader, configuredOrigin, serverBind) {
+  const requestHost = hostOnly(requestAuthority(requestUrl, hostHeader)).toLowerCase();
+  if (configuredOrigin) {
+    const url = new URL(configuredOrigin);
+    if (url.hostname.toLowerCase() === requestHost) return null;
+    return { origin: url.origin, host: url.hostname };
+  }
+  if (requestHost === "") return null;
+  const counterpart = loopbackCounterpart(requestHost);
+  if (!counterpart) return null;
+  if (!loopbackHostRoles(serverBind.host)) return null;
+  let protocol;
+  try {
+    protocol = new URL(requestUrl).protocol;
+  } catch {
+    protocol = "http:";
+  }
+  const suffix = protocol === "http:" && serverBind.port === 80 || protocol === "https:" && serverBind.port === 443 ? "" : `:${serverBind.port}`;
+  return { origin: `${protocol}//${counterpart}${suffix}`, host: counterpart };
+}
+
+// src/http/routes/me.ts
 function meRoutes(deps2) {
   const app2 = new Hono3();
   app2.get("/", (c) => {
-    return c.json({ user: toUserInfo(c.var.user) });
+    const target = resolvePreviewTarget(
+      c.req.url,
+      c.req.header("host"),
+      deps2.config.previewOrigin,
+      deps2.config
+    );
+    return c.json({
+      user: toUserInfo(c.var.user),
+      previewIsolated: target !== null
+    });
   });
   app2.put("/password", async (c) => {
     const body = await readJson(c);
@@ -1407,6 +1604,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.`);
@@ -1526,7 +1729,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");
@@ -2198,6 +2404,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);
     }
@@ -2287,11 +2496,23 @@ function agentConfigRoutes(deps2) {
       activeSessionCount: deps2.manager.activeCountForAgent(projectId, agentId)
     });
   });
+  app2.post("/reset", async (c) => {
+    const projectId = requireValidId(c, "projectId");
+    const agentId = requireValidId(c, "agentId");
+    deps2.projectService.requireProjectAccess(c.var.user.userId, projectId);
+    await deps2.agentConfigService.resetConfig(projectId, agentId);
+    const view = await deps2.agentConfigService.getConfig(projectId, agentId);
+    return c.json({
+      ...view,
+      activeSessionCount: deps2.manager.activeCountForAgent(projectId, agentId)
+    });
+  });
   return app2;
 }
 
 // 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) => {
@@ -2319,6 +2540,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;
 }
 
@@ -2617,6 +2873,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 {
@@ -2647,6 +2907,13 @@ var APPROVAL_MODES = [
   "read-only",
   "always-ask"
 ];
+var THINKING_LEVELS = ["none", "low", "medium", "high", "xhigh"];
+var SESSION_CATEGORIES = [
+  "active",
+  "subagent",
+  "schedule",
+  "archived"
+];
 function parseTaskInput(body) {
   const input = body.input;
   if (!Array.isArray(input) || input.length === 0) {
@@ -2673,6 +2940,18 @@ function parseTaskInput(body) {
     throw badRequest(`input[${i}].type must be one of text / image_url.`);
   });
 }
+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();
   app2.get("/", async (c) => {
@@ -2681,12 +2960,26 @@ function agentSessionsRoutes(deps2) {
     deps2.projectService.requireProjectAccess(c.var.user.userId, projectId);
     await deps2.agentConfigService.requireExists(projectId, agentId);
     const paging = optionalPagingQuery(c);
-    const sessions = await deps2.sessionService.listSessions(
+    const rawCategory = c.req.query("category");
+    if (rawCategory !== void 0 && !SESSION_CATEGORIES.includes(rawCategory)) {
+      throw badRequest(`category must be one of ${SESSION_CATEGORIES.join(" / ")}.`);
+    }
+    const rawCounts = c.req.query("counts");
+    if (rawCounts !== void 0 && rawCounts !== "1") throw badRequest("counts only accepts 1.");
+    const { sessions, counts, workspaceCounts } = await deps2.sessionService.listSessions(
       projectId,
       agentId,
-      ...paging ? [paging] : []
+      {
+        ...paging ? { paging } : {},
+        ...rawCategory !== void 0 ? { category: rawCategory } : {},
+        ...rawCounts !== void 0 ? { withCounts: true } : {}
+      }
     );
-    return c.json({ sessions });
+    return c.json({
+      sessions,
+      ...counts ? { counts } : {},
+      ...workspaceCounts ? { workspaceCounts } : {}
+    });
   });
   app2.post("/", async (c) => {
     const projectId = requireValidId(c, "projectId");
@@ -2744,8 +3037,10 @@ function sessionsRoutes(deps2) {
   app2.get("/:sessionId", async (c) => {
     const row = resolveSession(c);
     const hasTrace = await deps2.sessionService.hasTrace(row);
+    const info = await deps2.sessionService.toInfo(row, hasTrace);
+    const tracePath = hasTrace ? await deps2.sessionService.latestTracePath(row) : void 0;
     return c.json({
-      session: await deps2.sessionService.toInfo(row, hasTrace)
+      session: { ...info, ...tracePath !== void 0 ? { tracePath } : {} }
     });
   });
   app2.patch("/:sessionId", async (c) => {
@@ -2811,6 +3106,7 @@ function sessionsRoutes(deps2) {
         { 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);
@@ -2849,18 +3145,29 @@ function sessionsRoutes(deps2) {
   });
   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);
     const channel = deps2.channels.get(row.sessionId);
     const initialEvents = [
-      { type: "task_state", state: deps2.manager.statusOf(row.sessionId) },
+      {
+        type: "task_state",
+        state: deps2.manager.statusOf(row.sessionId),
+        queued: deps2.manager.pendingFollowUpCount(row.sessionId)
+      },
       ...deps2.manager.pendingApprovals(row.sessionId).map((p) => ({
         type: "approval_request",
         toolCall: p.toolCall,
@@ -2871,9 +3178,51 @@ function sessionsRoutes(deps2) {
   });
   app2.post("/:sessionId/tasks", async (c) => {
     const row = resolveSession(c);
-    const input = parseTaskInput(await readJson(c));
-    const { sessionId } = await deps2.manager.startTask(row.sessionId, input);
-    return c.json({ sessionId }, 202);
+    const body = await readJson(c);
+    const goal = parseGoalField(body);
+    const thinkingLevel = optionalEnum(body, "thinkingLevel", THINKING_LEVELS);
+    if (goal) {
+      const input2 = parseTaskInput(body);
+      const text = input2.filter((m) => m.payload.type === "text").map((m) => m.payload.text).join("\n").trim();
+      if (!text || input2.some((m) => m.payload.type !== "text")) {
+        throw badRequest("goal mode requires text-only input (the objective).");
+      }
+      const { sessionId: sessionId2 } = await deps2.manager.startGoal(row.sessionId, {
+        input: input2,
+        budget: goal.budget,
+        ...thinkingLevel !== void 0 ? { thinkingLevel } : {}
+      });
+      return c.json({ sessionId: sessionId2 }, 202);
+    }
+    const input = 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);
+  });
+  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);
+    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);
@@ -2894,6 +3243,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);
@@ -2927,6 +3281,31 @@ function sessionsRoutes(deps2) {
       }
     });
   });
+  app2.get("/:sessionId/files/preview-redirect", async (c) => {
+    const row = resolveSession(c);
+    const rel = c.req.query("path") ?? "";
+    const [exists] = await deps2.workspaceFiles.statExisting(row.workspace, [rel]);
+    if (!exists) throw new HttpError(404, "file_not_found", "File does not exist.");
+    const target = resolvePreviewTarget(
+      c.req.url,
+      c.req.header("host"),
+      deps2.config.previewOrigin,
+      deps2.config
+    );
+    if (!target) {
+      return c.redirect(
+        `/api/sessions/${row.sessionId}/files/content?path=${encodeURIComponent(rel)}&preview=1`,
+        302
+      );
+    }
+    const token = deps2.previewTokens.sign({
+      sessionId: row.sessionId,
+      host: target.host,
+      expiresAt: Date.now() + PREVIEW_TOKEN_TTL_MS
+    });
+    const encoded = rel.split("/").map(encodeURIComponent).join("/");
+    return c.redirect(`${target.origin}/preview/${token}/${encoded}`, 302);
+  });
   app2.post("/:sessionId/files/stat", async (c) => {
     const row = resolveSession(c);
     const body = await readJson(c);
@@ -2983,6 +3362,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;
@@ -3007,6 +3484,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);
@@ -3179,7 +3666,11 @@ import path8 from "path";
 import {
   createAgent,
   findLatestTraceFile,
+  goalFinishedOf,
+  goalTokenDelta,
+  isGoalRoundInput,
   isSessionMeta as isSessionMeta2,
+  stripLeadingMarkerBlocks,
   tracesDir
 } from "@prismshadow/penguin-core";
 
@@ -3250,6 +3741,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;
@@ -3277,6 +3927,9 @@ var TOOL_NAMES_MAX = 1e3;
 var ORIGIN_CTX_MAX = 200;
 var LLM_FAILURES = {
   failed: { code: "llm_failed", kind: "unexpected", text: "LLM request failed (not retryable)." },
+  // Credentials rejection shares the failed bucket (no new taxonomy): same code/kind, the
+  // real reason arrives via the abort reason or the event's own message as usual.
+  auth: { code: "llm_failed", kind: "unexpected", text: "LLM request failed (not retryable)." },
   timeout: {
     code: "llm_timeout",
     kind: "expected",
@@ -3289,7 +3942,7 @@ var LLM_FAILURES = {
   }
 };
 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";
@@ -3313,7 +3966,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();
@@ -3377,7 +4030,14 @@ 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") {
@@ -3395,12 +4055,12 @@ var StreamErrorWatcher = class {
    * up from it (see file header).
    */
   flush(key, reason) {
-    const status = this.pending.get(key);
-    if (status === void 0) return;
+    const entry = this.pending.get(key);
+    if (entry === void 0) return;
     this.pending.delete(key);
-    const spec = LLM_FAILURES[status];
+    const spec = 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,
@@ -3564,6 +4224,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) {
@@ -3575,6 +4237,19 @@ var SessionManager = class {
   pendingApprovals(sessionId) {
     return this.entries.get(sessionId)?.approvals.list() ?? [];
   }
+  /** Number of queued follow-up tasks (`queueIfBusy`) awaiting auto-start. */
+  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;
@@ -3597,6 +4272,7 @@ var SessionManager = class {
       abort: null,
       running: null,
       generation: this.generationOf(row.projectId, row.agentId),
+      followUps: [],
       lastActivityMs: Date.now()
     });
   }
@@ -3613,28 +4289,77 @@ 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 ——
   /**
    * Start a Task: get-or-load → 409
    * mutual-exclusion check → publish the input messages first → drive run in the
    * background. Returns the current actual session_id (the new id after self-heal).
+   * `opts.thinkingLevel` (optional, validated by the route) rides into this run's
+   * `session.run` options — a per-turn parameter, applied to this Task only.
+   * With `queueIfBusy`, a busy session (running/compacting) enqueues the input as a
+   * follow-up instead of 409: it auto-starts as an ordinary next task once the session
+   * returns to idle (`queued: true` in the result; see startQueuedFollowUp), keeping its
+   * thinkingLevel for that auto-start.
    */
-  async startTask(sessionId, input) {
+  async startTask(sessionId, input, opts) {
     return this.withLock(sessionId, async () => {
       this.assertOpen();
       this.assertAgentNotDeleting(sessionId);
       this.assertSessionNotDeleting(sessionId);
       const entry = await this.ensureEntry(sessionId);
+      if (entry.status !== "idle" && opts?.queueIfBusy) {
+        entry.followUps.push({
+          input,
+          ...opts.thinkingLevel !== void 0 ? { thinkingLevel: opts.thinkingLevel } : {}
+        });
+        entry.lastActivityMs = Date.now();
+        this.publishState(entry, entry.status);
+        return { sessionId: entry.sessionId, queued: true };
+      }
       this.assertIdle(entry);
-      const channel = this.deps.channels.get(entry.sessionId);
+      this.launchTask(entry, input, opts?.thinkingLevel);
+      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();
-      for (const msg of input) channel.publish(msg);
       this.publishState(entry, "running");
       const approve = makeApprove({
-        // Re-reads approval_mode from the DB on every decision (a PATCH takes effect immediately).
         getMode: () => this.deps.sessions.findById(entry.sessionId)?.approvalMode ?? "always-ask",
         toolPermission: (name) => entry.session.toolPermission(name),
         registry: entry.approvals,
@@ -3644,12 +4369,153 @@ var SessionManager = class {
           ...pending.origin !== void 0 ? { origin: pending.origin } : {}
         })
       });
-      const gen = entry.session.run(input, { approve, signal: ac.signal });
-      const userExcerpt = input.filter(isPlainText("user")).map((m) => m.payload.text).join("\n");
-      entry.running = this.drive(entry, gen, { userExcerpt });
+      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);
+    const ac = new AbortController();
+    entry.status = "running";
+    entry.abort = ac;
+    entry.lastActivityMs = Date.now();
+    for (const msg of input) channel.publish(msg);
+    this.publishState(entry, "running");
+    const approve = makeApprove({
+      // Re-reads approval_mode from the DB on every decision (a PATCH takes effect immediately).
+      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 gen = entry.session.run(input, {
+      approve,
+      signal: ac.signal,
+      ...thinkingLevel !== void 0 ? { thinkingLevel } : {}
+    });
+    const userExcerpt = input.filter(isPlainText("user")).map((m) => m.payload.text).join("\n");
+    entry.running = this.drive(entry, gen, { userExcerpt });
+  }
+  /**
+   * Auto-start of queued follow-ups: called from drive's finally whenever a Task or
+   * compaction finishes (abort included — follow-ups are future tasks the user queued, so
+   * an abort of the current run does not discard them). Re-validates everything under the
+   * session lock (another task may have snuck in, the server may be shutting down, the
+   * session may be getting deleted) and launches exactly one queued input — the next
+   * finish picks up the one after, keeping order and one-at-a-time semantics.
+   */
+  async startQueuedFollowUp(sessionId) {
+    try {
+      await this.withLock(sessionId, async () => {
+        if (this.closed || this.deletingSessions.has(sessionId)) return;
+        const row = this.deps.sessions.findById(sessionId);
+        if (row && this.deletingAgents.has(agentKey(row.projectId, row.agentId))) return;
+        const entry = this.entries.get(sessionId);
+        if (!entry || entry.status !== "idle" || entry.followUps.length === 0) return;
+        const next = entry.followUps.shift();
+        this.launchTask(entry, next.input, next.thinkingLevel);
+      });
+    } catch (err) {
+      this.log(`[followup] auto-start failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
   /** Manually compact the context: 409 if already running; compaction output also flows into the SSE channel. */
   async startCompact(sessionId) {
     return this.withLock(sessionId, async () => {
@@ -3676,6 +4542,39 @@ var SessionManager = class {
     if (!entry) return false;
     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.
+   */
+  steer(sessionId, text) {
+    const entry = this.entries.get(sessionId);
+    if (!entry || entry.status !== "running" || !entry.session.steer(text)) {
+      throw new HttpError(
+        409,
+        "not_running",
+        "This Session has no Task in progress; send the message as a new task instead."
+      );
+    }
+    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
@@ -3781,6 +4680,7 @@ var SessionManager = class {
   sweepIdle(now = Date.now(), idleMs = ENTRY_IDLE_MS) {
     for (const [key, entry] of this.entries) {
       if (entry.status !== "idle" || entry.approvals.size !== 0 || entry.running !== null) continue;
+      if (entry.followUps.length > 0) continue;
       if (now - entry.lastActivityMs <= idleMs) continue;
       this.entries.delete(key);
     }
@@ -3872,6 +4772,7 @@ var SessionManager = class {
       abort: null,
       running: null,
       generation,
+      followUps: [],
       lastActivityMs: Date.now()
     };
     this.entries.set(currentId, entry);
@@ -3949,6 +4850,7 @@ var SessionManager = class {
             }
           }
         }
+        this.liveTail.observe(entry.sessionId, msg);
         this.deps.channels.get(entry.sessionId).publish(msg);
         watcher?.observe(msg);
         try {
@@ -3965,6 +4867,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;
@@ -3976,6 +4879,7 @@ var SessionManager = class {
           fallbackText: titleSource.userExcerpt
         });
       }
+      if (entry.followUps.length > 0) void this.startQueuedFollowUp(entry.sessionId);
       for (const child of children.values()) {
         if (!child.prompt.trim()) continue;
         this.deps.titles?.maybeGenerate(
@@ -4046,7 +4950,7 @@ var SessionManager = class {
     return child;
   }
   publishState(entry, state) {
-    this.publishEvent(entry, { type: "task_state", state });
+    this.publishEvent(entry, { type: "task_state", state, queued: entry.followUps.length });
   }
   publishEvent(entry, event) {
     this.deps.channels.get(entry.sessionId).publish(event, "server_event");
@@ -4069,19 +4973,9 @@ var SessionManager = class {
 // src/runtime/scheduler.ts
 import { createHash as createHash3 } from "crypto";
 import { readdir } from "fs/promises";
-import { agentsDir, userText as userText2 } from "@prismshadow/penguin-core";
+import { agentsDir, buildScheduledMessage, userText as userText2 } from "@prismshadow/penguin-core";
 var TICK_INTERVAL_MS = 3e4;
-function scheduledMessage(name, firedAt, prompt) {
-  return [
-    "<scheduled_task>",
-    "This message was sent automatically by a scheduled task; its origin is listed below and the task prompt follows.",
-    `schedule: ${name}`,
-    `fired_at: ${firedAt}`,
-    "</scheduled_task>",
-    "",
-    prompt
-  ].join("\n");
-}
+var scheduledMessage = buildScheduledMessage;
 var Scheduler = class {
   constructor(deps2) {
     this.deps = deps2;
@@ -4500,7 +5394,7 @@ var UsageRecorder = class {
 };
 
 // src/services/ids.ts
-import { randomBytes as randomBytes3 } from "crypto";
+import { randomBytes as randomBytes4 } 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_]+$/;
@@ -4585,6 +5479,7 @@ import {
   VAULT_VALUE_MAX_LENGTH,
   isValidVaultKey,
   loadAgentVault,
+  resetSystemConfigToDefaults,
   saveAgentVault,
   systemConfigPath
 } from "@prismshadow/penguin-core";
@@ -4643,6 +5538,19 @@ 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 fs9.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;
@@ -4860,9 +5768,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
     };
   }
@@ -5013,7 +5923,7 @@ function probeTps(outputTokens, windowMs) {
 }
 
 // src/services/agent-config-service.ts
-var THINKING_LEVELS = ["none", "low", "medium", "high", "xhigh"];
+var THINKING_LEVELS2 = ["none", "low", "medium", "high", "xhigh"];
 var COMPACTION_MODES = ["summarize", "discard"];
 function asRecord(v) {
   return v !== null && typeof v === "object" && !Array.isArray(v) ? v : {};
@@ -5115,6 +6025,18 @@ var AgentConfigService = class {
       await fs10.writeFile(agentsMdPath(this.root, projectId, agentId), req.agentsMd, "utf8");
     }
   }
+  /**
+   * Overwrites system_config.yaml with the current code defaults (core's
+   * resetSystemConfigToDefaults) — same semantics as updating an installed skill:
+   * only the identity fields (name / description / version) survive; the system
+   * prompt, max_turns, model/compaction settings and the tool list (incl. MCP
+   * servers) become the current defaults. AGENTS.md, skills and the vault are
+   * untouched.
+   */
+  async resetConfig(projectId, agentId) {
+    await this.requireExists(projectId, agentId);
+    await resetSystemConfigToDefaults(this.root, projectId, agentId);
+  }
   async applyConfigUpdate(projectId, agentId, config2) {
     const cfg = config2;
     const yamlPath = systemConfigPath(this.root, projectId, agentId);
@@ -5143,7 +6065,7 @@ var AgentConfigService = class {
       );
       setIfProvided(
         ["model", "thinking_level"],
-        optionalEnum(model, "thinkingLevel", THINKING_LEVELS)
+        optionalEnum(model, "thinkingLevel", THINKING_LEVELS2)
       );
       setIfProvided(
         ["model", "timeoutMs"],
@@ -5237,6 +6159,7 @@ function validateToolsBuiltin(value) {
     if (t.forModel !== void 0 && t.forModel !== "vision" && t.forModel !== "text-only") {
       throw badRequest(`toolsBuiltin[${i}].forModel must be one of vision / text-only.`);
     }
+    optionalBoolean(t, "call_description", `toolsBuiltin[${i}].call_description`);
     optionalNumber(t, "timeoutMs", {
       integer: true,
       positiveOrMinusOne: true,
@@ -5615,7 +6538,7 @@ var BenchmarkService = class {
 };
 
 // src/services/snapshot-service.ts
-import { randomBytes as randomBytes4 } from "crypto";
+import { randomBytes as randomBytes5 } from "crypto";
 import fs13 from "fs/promises";
 import path12 from "path";
 import * as tar from "tar";
@@ -5661,7 +6584,7 @@ var SnapshotService = class {
     } catch {
     }
     await fs13.mkdir(dir, { recursive: true });
-    const tmp = `${file}.tmp-${randomBytes4(4).toString("hex")}`;
+    const tmp = `${file}.tmp-${randomBytes5(4).toString("hex")}`;
     await tar.create(
       {
         gzip: true,
@@ -5689,7 +6612,7 @@ 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-${randomBytes4(6).toString("hex")}`);
+    const staging = path12.join(base, `.import-${randomBytes5(6).toString("hex")}`);
     await fs13.mkdir(staging, { recursive: true });
     try {
       const archiveFile = path12.join(staging, "archive.tar.gz");
@@ -5971,6 +6894,7 @@ var ProjectService = class {
     this.deps.usage.deleteByProject(projectId);
     this.deps.errors.deleteByProject(projectId);
     this.deps.schedules.deleteByProject(projectId);
+    this.deps.goals.deleteByProject(projectId);
     await fs14.rm(projectDir(this.deps.root, projectId), { recursive: true, force: true });
   }
   // —— Member authorization ——
@@ -6043,15 +6967,39 @@ var ProjectService = class {
 
 // src/services/session-service.ts
 import path13 from "path";
-import { readdir as readdir2 } from "fs/promises";
+import { open, readdir as readdir2 } from "fs/promises";
 import {
   createAgent as createAgent2,
+  findLatestTraceFile as findLatestTraceFile2,
   isSessionMeta as isSessionMeta4,
+  parseTraceLines,
   readTraceTolerant,
   tracesDir as tracesDir2
 } from "@prismshadow/penguin-core";
 var TRACE_FILE_RE = /^(.+)_(\d{3})\.jsonl$/;
 var SESSION_ID_TS_RE = /^session-(\d{4})-(\d{2})-(\d{2})-(\d{2})-(\d{2})-(\d{2})-[0-9a-f]{8}$/;
+var TRACE_HEAD_BYTES = 256 * 1024;
+async function readTraceHead(filePath) {
+  const fh = await open(filePath, "r");
+  let text;
+  let truncated;
+  try {
+    const { buffer, bytesRead } = await fh.read(
+      Buffer.allocUnsafe(TRACE_HEAD_BYTES),
+      0,
+      TRACE_HEAD_BYTES,
+      0
+    );
+    text = buffer.subarray(0, bytesRead).toString("utf8");
+    truncated = bytesRead === TRACE_HEAD_BYTES;
+  } finally {
+    await fh.close();
+  }
+  if (!truncated) return parseTraceLines(text);
+  const nl = text.lastIndexOf("\n");
+  if (nl === -1) return readTraceTolerant(filePath);
+  return parseTraceLines(text.slice(0, nl + 1));
+}
 function sessionIdCreatedAt(sessionId) {
   const m = SESSION_ID_TS_RE.exec(sessionId);
   if (!m) return null;
@@ -6067,10 +7015,11 @@ var SessionService = class {
   /**
    * DB row -> SessionInfo (run status and pending approval count come from session-manager).
    * Async because `source` is derived from session_meta: a registry miss (Session predating
-   * this process) falls back to reading the Trace head once (see sourceOf).
+   * this process) falls back to reading the Trace head once (see sourceOf). `traces` is the
+   * list flow's one-walk discovery result; without it a miss locates the shard itself.
    */
-  async toInfo(row, hasTrace) {
-    const source = await this.sourceOf(row, hasTrace);
+  async toInfo(row, hasTrace, traces) {
+    const source = await this.sourceOf(row, hasTrace, traces);
     return {
       sessionId: row.sessionId,
       projectId: row.projectId,
@@ -6084,6 +7033,7 @@ var SessionService = class {
       createdAt: row.createdAt,
       status: this.deps.manager.statusOf(row.sessionId),
       pendingApprovalCount: this.deps.manager.pendingApprovalCount(row.sessionId),
+      pendingFollowUpCount: this.deps.manager.pendingFollowUpCount(row.sessionId),
       hasTrace,
       archived: (row.archivedAt ?? null) !== null
     };
@@ -6095,11 +7045,13 @@ var SessionService = class {
    * session_meta is read once and cached. A Session with no Trace yet stays unknown and
    * is NOT cached negatively — its meta may appear with the first run.
    */
-  async sourceOf(row, hasTrace) {
+  async sourceOf(row, hasTrace, traces) {
     const known = this.deps.sources.get(row.sessionId);
     if (known !== void 0) return known ?? void 0;
     if (!hasTrace) return void 0;
-    const meta = await this.readTraceMeta(row.projectId, row.agentId, row.sessionId);
+    const location = traces?.get(row.sessionId) ?? (await this.discoverTraces(row.projectId, row.agentId)).get(row.sessionId);
+    if (!location) return void 0;
+    const meta = await this.readTraceMeta(location);
     if (!meta) return void 0;
     const source = asSessionSource(meta.payload.source) ?? null;
     this.deps.sources.set(row.sessionId, source);
@@ -6107,8 +7059,17 @@ var SessionService = class {
   }
   /** Whether this Session already has a Trace record (a Task has been run). */
   async hasTrace(row) {
-    const ids = await this.discoverTraceSessionIds(row.projectId, row.agentId);
-    return ids.has(row.sessionId);
+    return (await this.discoverTraces(row.projectId, row.agentId)).has(row.sessionId);
+  }
+  /**
+   * The list category of a row: archived wins (an explicit user action), then the
+   * origin's bucket, and no/unknown source is `active` — the same precedence the
+   * sidebar's partition applies to loaded rows, so server filtering and client
+   * rendering can never disagree.
+   */
+  async categoryOf(row, hasTrace, traces) {
+    if ((row.archivedAt ?? null) !== null) return "archived";
+    return await this.sourceOf(row, hasTrace, traces) ?? "active";
   }
   /**
    * List: DB ∪ Trace directory discovery, sorted by createdAt descending. Optional
@@ -6116,22 +7077,58 @@ var SessionService = class {
    * more"); slicing happens before toInfo, so per-request source derivation (lazy
    * Trace-head reads) stays bounded by the page size. Discovery/adoption still scans
    * the whole directory — the union and global ordering need every id.
+   *
+   * `category` filters to one sidebar bucket **before** paging, so offset/limit page
+   * within the category. Filtering needs each walked row's category (a possible
+   * Trace-head read per row, cached in the sources registry); without `withCounts`
+   * the walk stops as soon as the requested page is complete. `withCounts` classifies
+   * every row and returns per-category totals over the whole list — plus the same
+   * totals broken down by Workspace path — so the sidebar can label the collapsed
+   * folders (and a workspace group can know its own share) without loading them.
    */
-  async listSessions(projectId, agentId, paging) {
-    const traceIds = await this.discoverTraceSessionIds(projectId, agentId);
+  async listSessions(projectId, agentId, opts = {}) {
+    const { paging, category, withCounts } = opts;
+    const traces = await this.discoverTraces(projectId, agentId);
     const rows = new Map(
       this.deps.sessions.listByAgent(projectId, agentId).map((r) => [r.sessionId, r])
     );
-    for (const sessionId of traceIds) {
+    for (const [sessionId, location] of traces) {
       if (rows.has(sessionId)) continue;
-      const discovered = await this.adoptTraceSession(projectId, agentId, sessionId);
+      const discovered = await this.adoptTraceSession(projectId, agentId, sessionId, location);
       if (discovered) rows.set(sessionId, discovered);
     }
     const sorted = [...rows.values()].sort(
       (a, b) => b.createdAt.localeCompare(a.createdAt) || b.sessionId.localeCompare(a.sessionId)
     );
-    const page = paging ? sorted.slice(paging.offset, paging.offset + paging.limit) : sorted;
-    return Promise.all(page.map((row) => this.toInfo(row, traceIds.has(row.sessionId))));
+    const toPage = (page) => Promise.all(page.map((row) => this.toInfo(row, traces.has(row.sessionId), traces)));
+    if (category === void 0 && !withCounts) {
+      return {
+        sessions: await toPage(
+          paging ? sorted.slice(paging.offset, paging.offset + paging.limit) : sorted
+        )
+      };
+    }
+    const want = paging ? paging.offset + paging.limit : Infinity;
+    const counts = { active: 0, subagent: 0, schedule: 0, archived: 0 };
+    const workspaceCounts = {};
+    const matched = [];
+    for (const row of sorted) {
+      if (!withCounts && matched.length >= want) break;
+      const cat = await this.categoryOf(row, traces.has(row.sessionId), traces);
+      counts[cat] += 1;
+      if (withCounts) {
+        const ws = workspaceCounts[row.workspace] ??= {
+          active: 0,
+          subagent: 0,
+          schedule: 0,
+          archived: 0
+        };
+        ws[cat] += 1;
+      }
+      if ((category === void 0 || cat === category) && matched.length < want) matched.push(row);
+    }
+    const sessions = await toPage(paging ? matched.slice(paging.offset, want) : matched);
+    return withCounts ? { sessions, counts, workspaceCounts } : { sessions };
   }
   /**
    * Session stats (Agents list card): total count = size of the union of DB index
@@ -6243,48 +7240,59 @@ var SessionService = class {
     this.deps.manager.adopt(row, session);
     return this.toInfo(row, false);
   }
-  /** Scans the Trace directory to get the set of session_ids with records. */
-  async discoverTraceSessionIds(projectId, agentId) {
-    const dir = tracesDir2(this.deps.root, projectId, agentId);
-    const ids = /* @__PURE__ */ new Set();
-    for (const dateDir of await listDirsSafe(dir)) {
-      for (const file of await listFilesSafe(path13.join(dir, dateDir))) {
-        const match = TRACE_FILE_RE.exec(file);
-        if (match) ids.add(match[1]);
-      }
-    }
-    return ids;
+  /**
+   * Absolute path of a Session's **latest** Trace file (the current context shard);
+   * undefined when no Trace exists. Costs a directory walk, so only the single-session
+   * GET includes it in the DTO (see SessionInfo.tracePath) — the web's `/model` switch
+   * hands it to the new session's `[model_switch_from]` block so the model can read the
+   * source history itself when it needs it.
+   */
+  async latestTracePath(row) {
+    const located = await findLatestTraceFile2(
+      tracesDir2(this.deps.root, row.projectId, row.agentId),
+      row.sessionId
+    );
+    return located?.path;
   }
   /**
-   * session_meta from the earliest Trace shard of a Session (the shard whose head carries
-   * the original meta); null when there is no readable Trace or it has no meta. Shared by
-   * adoption backfill and lazy `source` resolution.
+   * One walk over the Trace directory: session_id → its **earliest** shard (the shard
+   * whose head carries the original session_meta). Discovery (which Sessions have
+   * records) and the meta-read location come out of a single pass, so classifying every
+   * row (`counts=1`) costs one directory walk total instead of one per Session.
    */
-  async readTraceMeta(projectId, agentId, sessionId) {
+  async discoverTraces(projectId, agentId) {
     const dir = tracesDir2(this.deps.root, projectId, agentId);
-    let earliest = null;
+    const out = /* @__PURE__ */ new Map();
     for (const dateDir of await listDirsSafe(dir)) {
       for (const file of await listFilesSafe(path13.join(dir, dateDir))) {
         const match = TRACE_FILE_RE.exec(file);
-        if (!match || match[1] !== sessionId) continue;
+        if (!match) continue;
+        const sessionId = match[1];
         const index = Number(match[2]);
-        if (!earliest || index < earliest.index) {
-          earliest = { path: path13.join(dir, dateDir, file), index };
+        const cur = out.get(sessionId);
+        if (!cur || index < cur.index) {
+          out.set(sessionId, { path: path13.join(dir, dateDir, file), index });
         }
       }
     }
-    if (!earliest) return null;
+    return out;
+  }
+  /**
+   * session_meta from a located Trace shard head; null when unreadable or it has no
+   * meta. Shared by adoption backfill and lazy `source` resolution.
+   */
+  async readTraceMeta(location) {
     let messages;
     try {
-      messages = await readTraceTolerant(earliest.path);
+      messages = await readTraceHead(location.path);
     } catch {
       return null;
     }
     return messages.find(isSessionMeta4) ?? null;
   }
   /** Adopts a Session that exists only in the Trace directory: reads session_meta from the first line of the earliest index file. */
-  async adoptTraceSession(projectId, agentId, sessionId) {
-    const meta = await this.readTraceMeta(projectId, agentId, sessionId);
+  async adoptTraceSession(projectId, agentId, sessionId, location) {
+    const meta = await this.readTraceMeta(location);
     if (!meta) return null;
     if (typeof meta.payload.provider !== "string") return null;
     this.deps.sources.set(sessionId, asSessionSource(meta.payload.source) ?? null);
@@ -6328,8 +7336,16 @@ async function listFilesSafe(dir) {
 // src/services/trace-service.ts
 import fs15 from "fs/promises";
 import path14 from "path";
-import { agentsDir as agentsDir3, readTraceTolerant as readTraceTolerant2, tracesDir as tracesDir3 } from "@prismshadow/penguin-core";
+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;
@@ -6519,7 +7535,9 @@ var TraceService = class {
       const msg = messages[mi];
       const p = msg.payload;
       const hasOrigin = msg.origin !== void 0 && msg.origin.length > 0;
-      const startsUserTurn = !hasOrigin && !compactionActive && msg.type === "model_msg" && (p.type === "text" && p.role === "user" || p.type === "image_url");
+      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 startsCompactionTurn = !hasOrigin && msg.type === "event_msg" && p.type === "compaction_begin";
       if (startsUserTurn || startsCompactionTurn) {
         if (pendingFrom === null) pendingFrom = mi;
@@ -6737,6 +7755,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) {
@@ -6746,7 +7768,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 fs15.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 = path14.join(tracesDir3(this.root, projectId, agentId), date);
+    await fs15.mkdir(dir, { recursive: true });
+    const file = path14.join(dir, `${sessionId}_${String(index).padStart(3, "0")}.jsonl`);
+    try {
+      await fs15.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
+    };
   }
 };
 
@@ -6918,6 +8098,53 @@ var UsageService = class {
   }
 };
 
+// src/http/routes/preview.ts
+import { Hono as Hono20 } from "hono";
+var DIRECTORY_INDEX = "index.html";
+function previewRoutes(deps2) {
+  const app2 = new Hono20();
+  app2.get("/:token/*", async (c) => {
+    const token = c.req.param("token");
+    const payload = token ? deps2.previewTokens.verify(token) : null;
+    if (!payload) return c.text("Not found", 404);
+    const authority = requestAuthority(c.req.url, c.req.header("host"));
+    if (hostOnly(authority).toLowerCase() !== payload.host.toLowerCase()) {
+      return c.text("Not found", 404);
+    }
+    const row = deps2.sessionsRepo.findById(payload.sessionId);
+    if (!row) return c.text("Not found", 404);
+    const prefix = `/preview/${token}/`;
+    const raw = c.req.path.startsWith(prefix) ? c.req.path.slice(prefix.length) : "";
+    let rel;
+    try {
+      rel = decodeURIComponent(raw);
+    } catch {
+      return c.text("Not found", 404);
+    }
+    if (rel === "" || rel.endsWith("/")) rel += DIRECTORY_INDEX;
+    let file;
+    try {
+      file = await deps2.workspaceFiles.read(row.workspace, rel);
+    } catch {
+      return c.text("Not found", 404);
+    }
+    return new Response(new Uint8Array(file.data), {
+      status: 200,
+      headers: {
+        "Content-Type": file.contentType,
+        "X-Content-Type-Options": "nosniff",
+        // Without this, third-party requests made by the page leak the token-bearing
+        // URL through Referer — a risk that only exists because this origin exists to
+        // let third-party embeds run.
+        "Referrer-Policy": "no-referrer",
+        // Previews are per-token and short-lived; never let a shared cache keep them.
+        "Cache-Control": "no-store"
+      }
+    });
+  });
+  return app2;
+}
+
 // src/app.ts
 var MAX_BODY_BYTES = 20 * 1024 * 1024;
 function buildAppDeps(config2, overrides = {}) {
@@ -6933,11 +8160,13 @@ 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 snapshots = new SnapshotService(config2.root);
   const usageService = new UsageService(
@@ -6946,6 +8175,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"
@@ -6962,7 +8192,8 @@ function buildAppDeps(config2, overrides = {}) {
     recorder,
     errors,
     titles,
-    log
+    log,
+    goals: goalsRepo
   });
   managerRef = manager;
   const projectService = new ProjectService({
@@ -6975,6 +8206,7 @@ function buildAppDeps(config2, overrides = {}) {
     usage: usageRepo,
     errors: errorsRepo,
     schedules: schedulesRepo,
+    goals: goalsRepo,
     projectConfig: projectConfigService,
     manager
   });
@@ -7027,10 +8259,14 @@ function buildAppDeps(config2, overrides = {}) {
     sessionService,
     traceService,
     usageService,
+    updateCheck,
     workspaceFiles,
+    previewTokens,
     benchmarks,
     snapshots,
     schedulesRepo,
+    goalsRepo,
+    errorsRepo,
     scheduler,
     channels,
     manager,
@@ -7040,7 +8276,7 @@ function buildAppDeps(config2, overrides = {}) {
   };
 }
 function createApp(deps2) {
-  const app2 = new Hono19();
+  const app2 = new Hono21();
   app2.onError((err, c) => {
     const projectId = attributedProjectId(c, deps2);
     deps2.errors.record({
@@ -7057,6 +8293,21 @@ function createApp(deps2) {
     const ms = Math.round(performance.now() - start);
     deps2.log(`${c.req.method} ${c.req.path} ${c.res.status} ${ms}ms`);
   });
+  const previewRoles = deps2.config.previewOrigin ? null : loopbackHostRoles(deps2.config.host);
+  if (previewRoles) {
+    app2.use("*", async (c, next) => {
+      const host = hostOnly(requestAuthority(c.req.url, c.req.header("host"))).toLowerCase();
+      if (host === previewRoles.preview && !c.req.path.startsWith("/preview/")) {
+        if (c.req.path.startsWith("/api/")) {
+          throw new HttpError(401, "unauthorized", "The API is not served on the preview host.");
+        }
+        const url = new URL(c.req.url);
+        url.hostname = previewRoles.app;
+        return c.redirect(url.toString(), 302);
+      }
+      await next();
+    });
+  }
   app2.use("/api/*", async (c, next) => {
     const contentLength = Number(c.req.header("content-length") ?? 0);
     if (contentLength > MAX_BODY_BYTES) {
@@ -7069,6 +8320,7 @@ function createApp(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());
@@ -7087,6 +8339,7 @@ function createApp(deps2) {
   app2.route("/api/projects/:projectId/agents/:agentId/sessions", agentSessionsRoutes(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)) {
     registerStaticRoutes(app2, deps2.config.webDist);
   }
@@ -7160,6 +8413,19 @@ function defaultWebDist() {
   if (fs17.existsSync(bundled)) return bundled;
   return path16.resolve(here, "..", "..", "web", "dist");
 }
+function normalizePreviewOrigin(raw) {
+  if (!raw || raw.trim() === "") return null;
+  let url;
+  try {
+    url = new URL(raw.trim());
+  } catch {
+    throw new Error(`Invalid PENGUIN_PREVIEW_ORIGIN=${raw} (expected an absolute origin)`);
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error(`Invalid PENGUIN_PREVIEW_ORIGIN=${raw} (only http/https are supported)`);
+  }
+  return url.origin;
+}
 function resolveServerConfig(env = process.env) {
   const root = env.PENGUIN_HOME ?? resolveRoot();
   const port = Number(env.PORT || DEFAULT_SERVER_PORT);
@@ -7172,6 +8438,7 @@ function resolveServerConfig(env = process.env) {
     port,
     dbPath: env.PENGUIN_WEB_DB ?? path16.join(root, "web.db"),
     webDist: env.PENGUIN_WEB_DIST ?? defaultWebDist(),
+    previewOrigin: normalizePreviewOrigin(env.PENGUIN_PREVIEW_ORIGIN),
     authSessionTtlMs: 7 * DAY_MS,
     authSessionRenewMs: 6 * DAY_MS
   };
@@ -7184,11 +8451,19 @@ 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://${config.host}:${info.port}`);
+  console.log(`penguin-server started: http://${appHost}:${info.port}`);
   console.log(`Data root: ${config.root}`);
   console.log(`SQLite: ${config.dbPath}`);
 });
+var ipv6Loopback = config.host === "127.0.0.1" || config.host === "localhost" ? serve({ fetch: app.fetch, hostname: "::1", port: config.port }) : null;
+ipv6Loopback?.on("error", (err) => {
+  console.warn(
+    `[server] IPv6 loopback listener unavailable (${err.code ?? err.message}); previews via localhost may not resolve.`
+  );
+});
 var shuttingDown = false;
 async function shutdown(signal, exitCode = 0) {
   if (shuttingDown) return;
@@ -7197,6 +8472,7 @@ async function shutdown(signal, exitCode = 0) {
   deps.scheduler.stop();
   await deps.manager.shutdown(5e3);
   deps.channels.dispose();
+  ipv6Loopback?.close();
   server.close(() => {
     deps.db.close();
     process.exit(exitCode);