@prismshadow/penguin-server 0.2.1 → 0.2.2

package/dist/index.js

@@ -2,21 +2,79 @@ import {
   acquireServerLock,
   liveServerLock,
   releaseServerLock
-} from "./chunk-V6KH4FRG.js";
+} from "./chunk-OMBFPEGQ.js";
+import {
+  clearInitialAdminPassword,
+  readInitialAdminPassword,
+  renderInitialPasswordNotice,
+  storeInitialAdminPassword
+} from "./chunk-UUJCF46V.js";
 
 // src/index.ts
-import fs22 from "fs";
-import path18 from "path";
+import fs23 from "fs";
+import path19 from "path";
 import { config as loadDotenv } from "dotenv";
 import { serve } from "@hono/node-server";
 
 // src/app.ts
-import fs20 from "fs";
+import fs21 from "fs";
 import fsp from "fs/promises";
-import path16 from "path";
-import { Hono as Hono23 } from "hono";
+import path17 from "path";
+import { Hono as Hono25 } from "hono";
 import { bodyLimit } from "hono/body-limit";
 
+// src/net/proxy.ts
+import { Agent, EnvHttpProxyAgent, fetch as undiciFetch, setGlobalDispatcher } from "undici";
+var LOOPBACK_NO_PROXY = ["localhost", "127.0.0.1", "::1"];
+function mergedNoProxy(env = process.env) {
+  const raw = env.no_proxy ?? env.NO_PROXY ?? "";
+  const entries = raw.split(/[,\s]/).filter((e) => e !== "");
+  const present = new Set(entries.map((e) => e.toLowerCase()));
+  for (const name of LOOPBACK_NO_PROXY) {
+    if (!present.has(name)) entries.push(name);
+  }
+  return entries.join(",");
+}
+function normalizeProxyUrl(raw) {
+  const trimmed = raw.trim();
+  if (trimmed === "") return null;
+  const candidate = /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(trimmed) ? trimmed : `http://${trimmed}`;
+  let url;
+  try {
+    url = new URL(candidate);
+  } catch {
+    return null;
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") return null;
+  if (url.hostname === "" || url.username !== "" || url.password !== "") return null;
+  if (url.pathname !== "/" && url.pathname !== "" || url.search !== "" || url.hash !== "") {
+    return null;
+  }
+  return url.origin;
+}
+function envProxyAgentOptions(proxyUrl, env) {
+  const noProxy = mergedNoProxy(env);
+  return proxyUrl === null ? { noProxy } : { httpProxy: proxyUrl, httpsProxy: proxyUrl, noProxy };
+}
+function buildProxyDispatcher(settings, env) {
+  if (!settings.proxyForApp) return new Agent();
+  return new EnvHttpProxyAgent(envProxyAgentOptions(settings.proxyUrl, env));
+}
+var current = { proxyForApp: true, proxyUrl: null };
+var installed = false;
+function installGlobalProxyDispatcher() {
+  installed = true;
+  setGlobalDispatcher(buildProxyDispatcher(current));
+  globalThis.fetch = undiciFetch;
+}
+function applyProxySettings(settings) {
+  if (settings.proxyForApp === current.proxyForApp && settings.proxyUrl === current.proxyUrl) {
+    return;
+  }
+  current = { proxyForApp: settings.proxyForApp, proxyUrl: settings.proxyUrl };
+  if (installed) setGlobalDispatcher(buildProxyDispatcher(current));
+}
+
 // src/db/database.ts
 import { mkdirSync } from "fs";
 import path from "path";
@@ -133,6 +191,10 @@ 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
 );
+CREATE TABLE IF NOT EXISTS server_settings (   -- admin-level server-global settings (GET/PUT /api/admin/settings)
+  key   TEXT PRIMARY KEY,                     -- setting name, e.g. 'proxy_for_app'
+  value TEXT NOT NULL                         -- JSON-encoded value; an absent row means the setting's built-in default
+);
 CREATE TABLE IF NOT EXISTS trace_files (       -- DERIVED CACHE of the on-disk Trace tree (services/trace-index.ts): the directories stay the single source of truth, every row is rebuildable from disk, and a row is never authority for absence \u2014 consumers reconcile + retry on a miss, so a stale index costs one extra scan, never a false 404
   project_id TEXT NOT NULL,
   agent_id   TEXT NOT NULL,
@@ -650,6 +712,67 @@ var SchedulesRepo = class {
   }
 };
 
+// src/db/repos/server-settings.ts
+var PROXY_FOR_APP_KEY = "proxy_for_app";
+var PROXY_FOR_AGENT_KEY = "proxy_for_agent";
+var LEGACY_USE_SYSTEM_PROXY_KEY = "use_system_proxy";
+var PROXY_URL_KEY = "proxy_url";
+var ServerSettingsRepo = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  /** Returns the raw JSON-encoded value; null if never set. */
+  get(key) {
+    const r = this.db.prepare("SELECT value FROM server_settings WHERE key = ?").get(key);
+    return r ? r.value : null;
+  }
+  set(key, value) {
+    this.db.prepare(
+      `INSERT INTO server_settings (key, value) VALUES (?, ?)
+         ON CONFLICT(key) DO UPDATE SET value = excluded.value`
+    ).run(key, value);
+  }
+  /** Shared switch read: this key if present, else the legacy single switch, else the default: on. */
+  getProxySwitch(key) {
+    const raw = this.get(key);
+    if (raw !== null) return raw !== "false";
+    return this.get(LEGACY_USE_SYSTEM_PROXY_KEY) !== "false";
+  }
+  /** The "application uses the proxy" switch (the server's own outbound dispatcher). */
+  getProxyForApp() {
+    return this.getProxySwitch(PROXY_FOR_APP_KEY);
+  }
+  setProxyForApp(value) {
+    this.set(PROXY_FOR_APP_KEY, JSON.stringify(value));
+  }
+  /** The "agent environment uses the proxy" switch (command subprocess env policy). */
+  getProxyForAgent() {
+    return this.getProxySwitch(PROXY_FOR_AGENT_KEY);
+  }
+  setProxyForAgent(value) {
+    this.set(PROXY_FOR_AGENT_KEY, JSON.stringify(value));
+  }
+  /**
+   * The explicit proxy address (normalized at write time by the settings route); null =
+   * follow the proxy environment variables. An absent or unreadable row reads as null
+   * (the safe default: behave as before the setting existed).
+   */
+  getProxyUrl() {
+    const raw = this.get(PROXY_URL_KEY);
+    if (raw === null) return null;
+    try {
+      const value = JSON.parse(raw);
+      return typeof value === "string" && value !== "" ? value : null;
+    } catch {
+      return null;
+    }
+  }
+  setProxyUrl(value) {
+    this.set(PROXY_URL_KEY, JSON.stringify(value));
+  }
+};
+
 // src/db/repos/sessions.ts
 function mapRow4(r) {
   return {
@@ -1305,6 +1428,10 @@ var AuthService = class {
     }
     return password;
   }
+  /** Whether the built-in admin still runs on its initial password (drives the startup reminder notice). */
+  adminPasswordIsInitial() {
+    return this.deps.users.findById(ADMIN_USER_ID)?.passwordIsInitial === true;
+  }
   /** Consecutive login failures per userId (see the throttling comment on the constants). */
   loginFailures = /* @__PURE__ */ new Map();
   /** The wait imposed after `failures` consecutive failures (0 while within the free attempts). */
@@ -1366,6 +1493,7 @@ var AuthService = class {
       throw new HttpError(400, "invalid_password", "Password must be at least 8 characters.");
     }
     this.deps.users.updatePassword(userId, await hashPassword(newPassword), false);
+    this.deps.onPasswordChanged?.(userId);
   }
   /**
    * Desktop-session password set: no old-password check. Only reachable for sessions
@@ -1378,6 +1506,7 @@ var AuthService = class {
       throw new HttpError(400, "invalid_password", "Password must be at least 8 characters.");
     }
     this.deps.users.updatePassword(userId, await hashPassword(newPassword), false);
+    this.deps.onPasswordChanged?.(userId);
   }
   logout(token) {
     this.deps.authSessions.delete(sha256Hex(token));
@@ -1418,7 +1547,38 @@ var AuthService = class {
 };
 
 // src/http/routes/admin.ts
+import { Hono as Hono2 } from "hono";
+
+// src/http/routes/desktop.ts
 import { Hono } from "hono";
+function rejectInDesktopMode(deps2) {
+  return async (_c, next) => {
+    if (deps2.desktop !== null) {
+      throw new HttpError(
+        403,
+        "desktop_single_user",
+        "User management is disabled in the desktop app (single-user mode)."
+      );
+    }
+    await next();
+  };
+}
+var SHUTDOWN_DELAY_MS = 50;
+function desktopRoutes(deps2) {
+  const app2 = new Hono();
+  app2.post("/shutdown", (c) => {
+    const desktop = deps2.desktop;
+    if (!desktop) throw new HttpError(404, "not_found", "Desktop mode is not enabled.");
+    const header = c.req.header("authorization") ?? "";
+    const token = header.startsWith("Bearer ") ? header.slice("Bearer ".length) : "";
+    if (token === "" || !desktop.verifyToken(token)) {
+      throw new HttpError(401, "unauthorized", "Invalid desktop token.");
+    }
+    setTimeout(() => desktop.requestShutdown(), SHUTDOWN_DELAY_MS).unref();
+    return c.body(null, 202);
+  });
+  return app2;
+}
 
 // src/http/validate.ts
 import { isValidId } from "@prismshadow/penguin-core";
@@ -1546,7 +1706,8 @@ function optionalDateParam(value, label) {
 
 // src/http/routes/admin.ts
 function adminUsersRoutes(deps2) {
-  const app2 = new Hono();
+  const app2 = new Hono2();
+  app2.use("*", rejectInDesktopMode(deps2));
   app2.use("*", async (c, next) => {
     if (!c.var.user.isAdmin) {
       throw new HttpError(403, "admin_required", "Only an admin can perform this operation.");
@@ -1576,8 +1737,57 @@ function adminUsersRoutes(deps2) {
   return app2;
 }
 
+// src/http/routes/admin-settings.ts
+import { Hono as Hono3 } from "hono";
+function parseProxyUrl(value) {
+  if (value === null) return null;
+  if (typeof value === "string") {
+    if (value.trim() === "") return null;
+    const normalized = normalizeProxyUrl(value);
+    if (normalized !== null) return normalized;
+  }
+  throw new HttpError(
+    400,
+    "invalid_proxy_url",
+    "proxyUrl must be http://host[:port], https://host[:port], or host[:port] (empty or null clears it)."
+  );
+}
+function adminSettingsRoutes(deps2) {
+  const app2 = new Hono3();
+  app2.use("*", async (c, next) => {
+    if (!c.var.user.isAdmin) {
+      throw new HttpError(403, "admin_required", "Only an admin can perform this operation.");
+    }
+    await next();
+  });
+  const settings = () => ({
+    settings: {
+      proxyForApp: deps2.serverSettingsRepo.getProxyForApp(),
+      proxyForAgent: deps2.serverSettingsRepo.getProxyForAgent(),
+      proxyUrl: deps2.serverSettingsRepo.getProxyUrl()
+    }
+  });
+  app2.get("/", (c) => c.json(settings()));
+  app2.put("/", async (c) => {
+    const body = await readJson(c);
+    const proxyForApp = optionalBoolean(body, "proxyForApp");
+    const proxyForAgent = optionalBoolean(body, "proxyForAgent");
+    const proxyUrlProvided = body.proxyUrl !== void 0;
+    const proxyUrl = proxyUrlProvided ? parseProxyUrl(body.proxyUrl) : null;
+    if (proxyForApp !== void 0) deps2.serverSettingsRepo.setProxyForApp(proxyForApp);
+    if (proxyForAgent !== void 0) deps2.serverSettingsRepo.setProxyForAgent(proxyForAgent);
+    if (proxyUrlProvided) deps2.serverSettingsRepo.setProxyUrl(proxyUrl);
+    applyProxySettings({
+      proxyForApp: deps2.serverSettingsRepo.getProxyForApp(),
+      proxyUrl: deps2.serverSettingsRepo.getProxyUrl()
+    });
+    return c.json(settings());
+  });
+  return app2;
+}
+
 // src/http/routes/auth.ts
-import { Hono as Hono2 } from "hono";
+import { Hono as Hono4 } from "hono";
 import { deleteCookie, getCookie as getCookie2, setCookie } from "hono/cookie";
 function cookieOptions(c) {
   return {
@@ -1590,7 +1800,7 @@ function cookieOptions(c) {
   };
 }
 function authRoutes(deps2) {
-  const app2 = new Hono2();
+  const app2 = new Hono4();
   app2.post("/login", async (c) => {
     const body = await readJson(c);
     const userId = requireString(body, "userId", { label: "userId" });
@@ -1620,7 +1830,7 @@ function authRoutes(deps2) {
 }
 
 // src/http/routes/me.ts
-import { Hono as Hono3 } from "hono";
+import { Hono as Hono5 } from "hono";
 
 // src/services/preview-token.ts
 import { createHmac, randomBytes as randomBytes3, timingSafeEqual as timingSafeEqual2 } from "crypto";
@@ -1715,7 +1925,7 @@ function resolvePreviewTarget(requestUrl, hostHeader, configuredOrigin, serverBi
 
 // src/http/routes/me.ts
 function meRoutes(deps2) {
-  const app2 = new Hono3();
+  const app2 = new Hono5();
   app2.get("/", (c) => {
     const target = resolvePreviewTarget(
       c.req.url,
@@ -1757,15 +1967,15 @@ function meRoutes(deps2) {
   app2.put("/prefs", async (c) => {
     const body = await readJson(c);
     const raw = deps2.prefsRepo.get(c.var.user.userId);
-    let current = {};
+    let current2 = {};
     if (raw !== null) {
       try {
-        current = JSON.parse(raw);
+        current2 = JSON.parse(raw);
       } catch {
-        current = {};
+        current2 = {};
       }
     }
-    const merged = { ...current, ...body };
+    const merged = { ...current2, ...body };
     deps2.prefsRepo.set(c.var.user.userId, JSON.stringify(merged));
     return c.json({ prefs: merged });
   });
@@ -1773,7 +1983,7 @@ function meRoutes(deps2) {
 }
 
 // src/http/routes/events.ts
-import { Hono as Hono4 } from "hono";
+import { Hono as Hono6 } from "hono";
 
 // src/http/sse.ts
 import { streamSSE } from "hono/streaming";
@@ -1840,7 +2050,7 @@ function userChannelKey(userId) {
   return `user:${userId}`;
 }
 function eventsRoutes(deps2) {
-  const app2 = new Hono4();
+  const app2 = new Hono6();
   app2.get("/", (c) => {
     const channel = deps2.channels.get(userChannelKey(c.var.user.userId));
     return sseEndpoint(c, channel, { initialEvents: [{ type: "hello" }] });
@@ -1849,9 +2059,9 @@ function eventsRoutes(deps2) {
 }
 
 // src/http/routes/projects.ts
-import { Hono as Hono5 } from "hono";
+import { Hono as Hono7 } from "hono";
 function projectsRoutes(deps2) {
-  const app2 = new Hono5();
+  const app2 = new Hono7();
   app2.get("/", async (c) => {
     const projects = await deps2.projectService.listProjects(c.var.user.userId);
     return c.json({ projects });
@@ -1879,9 +2089,10 @@ function projectsRoutes(deps2) {
 }
 
 // src/http/routes/members.ts
-import { Hono as Hono6 } from "hono";
+import { Hono as Hono8 } from "hono";
 function membersRoutes(deps2) {
-  const app2 = new Hono6();
+  const app2 = new Hono8();
+  app2.use("*", rejectInDesktopMode(deps2));
   app2.get("/", (c) => {
     const members = deps2.projectService.listMembers(
       c.var.user.userId,
@@ -1911,7 +2122,7 @@ function membersRoutes(deps2) {
 }
 
 // src/http/routes/models.ts
-import { Hono as Hono7 } from "hono";
+import { Hono as Hono9 } from "hono";
 function publishCredentialsUpdated(deps2, projectId) {
   const event = { type: "credentials_updated" };
   for (const row of deps2.sessionsRepo.listByProject(projectId)) {
@@ -2027,7 +2238,7 @@ function parseModelsUpdate(body) {
   return req;
 }
 function modelsRoutes(deps2) {
-  const app2 = new Hono7();
+  const app2 = new Hono9();
   app2.get("/", async (c) => {
     const projectId = requireValidId(c, "projectId");
     deps2.projectService.requireProjectAccess(c.var.user.userId, projectId);
@@ -2089,13 +2300,13 @@ function modelsRoutes(deps2) {
 }
 
 // src/http/routes/chat-defaults.ts
-import { Hono as Hono9 } from "hono";
+import { Hono as Hono11 } from "hono";
 import { DEFAULT_CHAT_THINKING_LEVELS, isValidId as isValidId2 } from "@prismshadow/penguin-core";
 
 // src/http/routes/sessions.ts
 import fs4 from "fs/promises";
 import path4 from "path";
-import { Hono as Hono8 } from "hono";
+import { Hono as Hono10 } from "hono";
 import { imageUrlMessage, scratchpadDir, userText } from "@prismshadow/penguin-core";
 
 // src/services/message-window.ts
@@ -2323,7 +2534,7 @@ async function assertWorkspaceAllowed(args) {
     throw new HttpError(
       400,
       "workspace_not_found",
-      `Workspace does not exist or is inaccessible: ${args.workspace}. Specify an existing directory, or leave it empty to use a temporary directory.`
+      `Workspace does not exist or is inaccessible: ${args.workspace}. Specify an existing directory, or leave it empty to use a temporary workspace.`
     );
   }
   const stat = await fs.stat(ws);
@@ -2770,6 +2981,12 @@ function pageLimit(raw, name) {
   }
   return v;
 }
+function appendPendingInputs(messages, pending) {
+  if (pending.length === 0) return messages;
+  const tail = new Set(messages.slice(-50).map((m) => JSON.stringify(m)));
+  const missing = pending.filter((m) => !tail.has(JSON.stringify(m)));
+  return missing.length > 0 ? [...messages, ...missing] : messages;
+}
 function messagesPageQuery(c) {
   const rawTail = c.req.query("tailLimit");
   const rawBefore = c.req.query("before");
@@ -2883,7 +3100,7 @@ function parseGoalField(body) {
   return { budget: budget ?? -1 };
 }
 function agentSessionsRoutes(deps2) {
-  const app2 = new Hono8();
+  const app2 = new Hono10();
   app2.get("/", async (c) => {
     const projectId = requireValidId(c, "projectId");
     const agentId = requireValidId(c, "agentId");
@@ -2945,7 +3162,7 @@ function agentSessionsRoutes(deps2) {
   return app2;
 }
 function sessionsRoutes(deps2) {
-  const app2 = new Hono8();
+  const app2 = new Hono10();
   const resolveSession = (c) => {
     const sessionId = c.req.param("sessionId");
     const row = sessionId ? deps2.sessionsRepo.findById(sessionId) : null;
@@ -3089,11 +3306,18 @@ function sessionsRoutes(deps2) {
     const row = resolveSession(c);
     const page = messagesPageQuery(c);
     let live;
-    if (page?.kind !== "before" && deps2.manager.statusOf(row.sessionId) !== "idle") {
-      live = {
-        cursor: deps2.channels.get(row.sessionId).lastEventId,
-        fragments: deps2.manager.liveFragments(row.sessionId)
-      };
+    let pendingInputs = [];
+    if (page?.kind !== "before") {
+      if (deps2.manager.statusOf(row.sessionId) !== "idle") {
+        live = {
+          cursor: deps2.channels.get(row.sessionId).lastEventId,
+          fragments: deps2.manager.liveFragments(row.sessionId)
+        };
+      }
+      pendingInputs = [
+        ...deps2.manager.pendingInputs(row.sessionId),
+        ...deps2.manager.pendingBootstrap(row.sessionId)
+      ];
     }
     if (page !== null) {
       const result = await deps2.traceService.readMessagesPage(
@@ -3113,7 +3337,7 @@ function sessionsRoutes(deps2) {
         }
       };
       return c.json({
-        messages: result.messages,
+        messages: appendPendingInputs(result.messages, pendingInputs),
         ...live !== void 0 ? { live } : {},
         page: info
       });
@@ -3123,7 +3347,10 @@ function sessionsRoutes(deps2) {
       row.agentId,
       row.sessionId
     );
-    return c.json({ messages, ...live !== void 0 ? { live } : {} });
+    return c.json({
+      messages: appendPendingInputs(messages, pendingInputs),
+      ...live !== void 0 ? { live } : {}
+    });
   });
   app2.get("/:sessionId/stream", (c) => {
     const row = resolveSession(c);
@@ -3247,6 +3474,30 @@ function sessionsRoutes(deps2) {
     const aborted = deps2.manager.abortTask(row.sessionId);
     return c.body(null, aborted ? 202 : 204);
   });
+  app2.get("/:sessionId/processes", (c) => {
+    const row = resolveSession(c);
+    const processes = deps2.manager.listProcesses(row.sessionId).map((p) => ({
+      processId: p.processId,
+      pid: p.pid,
+      cmd: p.cmd,
+      cwd: p.cwd,
+      startedAt: new Date(p.startedAt).toISOString(),
+      running: p.running
+    }));
+    return c.json({ processes });
+  });
+  app2.post("/:sessionId/processes/:processId/kill", (c) => {
+    const row = resolveSession(c);
+    const killed = deps2.manager.killProcess(row.sessionId, pathParam(c, "processId"));
+    if (!killed) {
+      throw new HttpError(
+        404,
+        "process_not_found",
+        "Process does not exist or has already exited."
+      );
+    }
+    return c.body(null, 204);
+  });
   app2.post("/:sessionId/retry-now", (c) => {
     const row = resolveSession(c);
     const skipped = deps2.manager.retryNow(row.sessionId);
@@ -3368,7 +3619,7 @@ function sessionsRoutes(deps2) {
 
 // src/http/routes/chat-defaults.ts
 function chatDefaultsRoutes(deps2) {
-  const app2 = new Hono9();
+  const app2 = new Hono11();
   app2.get("/", async (c) => {
     const projectId = requireValidId(c, "projectId");
     deps2.projectService.requireProjectAccess(c.var.user.userId, projectId);
@@ -3402,7 +3653,7 @@ function chatDefaultsRoutes(deps2) {
 }
 
 // src/http/routes/vault.ts
-import { Hono as Hono10 } from "hono";
+import { Hono as Hono12 } from "hono";
 function parseVaultUpdate(body) {
   if (!Array.isArray(body.entries)) throw badRequest("entries must be an array.");
   const entries = body.entries.map((item, i) => {
@@ -3424,7 +3675,7 @@ function parseVaultUpdate(body) {
   return { entries };
 }
 function vaultRoutes(deps2) {
-  const app2 = new Hono10();
+  const app2 = new Hono12();
   app2.get("/", async (c) => {
     const projectId = requireValidId(c, "projectId");
     const agentId = requireValidId(c, "agentId");
@@ -3440,12 +3691,62 @@ function vaultRoutes(deps2) {
     deps2.manager.invalidateAgentRuntimes(projectId, agentId);
     return c.json(res);
   });
+  app2.post("/template-placeholder", async (c) => {
+    const projectId = requireValidId(c, "projectId");
+    const agentId = requireValidId(c, "agentId");
+    deps2.projectService.requireProjectOwner(c.var.user.userId, projectId);
+    const view = await deps2.agentConfigService.insertTemplatePlaceholder(
+      projectId,
+      agentId,
+      "vault"
+    );
+    return c.json(view.config.vault);
+  });
+  return app2;
+}
+
+// src/http/routes/memory.ts
+import { Hono as Hono13 } from "hono";
+function memoryRoutes(deps2) {
+  const app2 = new Hono13();
+  const scope = (c) => {
+    const projectId = requireValidId(c, "projectId");
+    const agentId = requireValidId(c, "agentId");
+    deps2.projectService.requireProjectAccess(c.var.user.userId, projectId);
+    return { projectId, agentId };
+  };
+  app2.get("/", async (c) => {
+    const { projectId, agentId } = scope(c);
+    return c.json(await deps2.memoryService.overview(projectId, agentId));
+  });
+  app2.post("/template-placeholder", async (c) => {
+    const { projectId, agentId } = scope(c);
+    return c.json(await deps2.memoryService.insertTemplatePlaceholder(projectId, agentId));
+  });
+  app2.get("/scopes/:scopeKey/files", async (c) => {
+    const { projectId, agentId } = scope(c);
+    const key = pathParam(c, "scopeKey");
+    return c.json(await deps2.memoryService.listFiles(projectId, agentId, key));
+  });
+  app2.get("/scopes/:scopeKey/files/:fileName", async (c) => {
+    const { projectId, agentId } = scope(c);
+    const key = pathParam(c, "scopeKey");
+    const name = pathParam(c, "fileName");
+    return c.json(await deps2.memoryService.readFile(projectId, agentId, key, name));
+  });
+  app2.delete("/scopes/:scopeKey/files/:fileName", async (c) => {
+    const { projectId, agentId } = scope(c);
+    const key = pathParam(c, "scopeKey");
+    const name = pathParam(c, "fileName");
+    await deps2.memoryService.deleteFile(projectId, agentId, key, name);
+    return c.body(null, 204);
+  });
   return app2;
 }
 
 // src/http/routes/schedules.ts
 import { createHash as createHash2 } from "crypto";
-import { Hono as Hono11 } from "hono";
+import { Hono as Hono14 } from "hono";
 import { isValidId as isValidId3 } from "@prismshadow/penguin-core";
 
 // src/runtime/schedule-file.ts
@@ -3827,7 +4128,7 @@ function requireScheduleName(raw) {
   return raw;
 }
 function scheduleRoutes(deps2) {
-  const app2 = new Hono11();
+  const app2 = new Hono14();
   app2.get("/", async (c) => {
     const projectId = requireValidId(c, "projectId");
     const agentId = requireValidId(c, "agentId");
@@ -3854,6 +4155,17 @@ function scheduleRoutes(deps2) {
     await upsert(deps2, c.var.user.userId, projectId, agentId, name, body);
     return c.json(await readItem(deps2, projectId, agentId, name), 201);
   });
+  app2.post("/template-placeholder", async (c) => {
+    const projectId = requireValidId(c, "projectId");
+    const agentId = requireValidId(c, "agentId");
+    deps2.projectService.requireProjectOwner(c.var.user.userId, projectId);
+    const view = await deps2.agentConfigService.insertTemplatePlaceholder(
+      projectId,
+      agentId,
+      "schedules"
+    );
+    return c.json(view.config.schedules);
+  });
   app2.get("/:name", async (c) => {
     const projectId = requireValidId(c, "projectId");
     const agentId = requireValidId(c, "agentId");
@@ -3915,7 +4227,7 @@ async function readItem(deps2, projectId, agentId, name) {
 }
 
 // src/http/routes/benchmarks.ts
-import { Hono as Hono12 } from "hono";
+import { Hono as Hono15 } from "hono";
 var TEXT_PREVIEW_BYTES = 256 * 1024;
 function listCaseFiles(deps2, material) {
   return async (c) => {
@@ -3968,7 +4280,7 @@ function readCaseFile(deps2, material) {
   };
 }
 function benchmarksRoutes(deps2) {
-  const app2 = new Hono12();
+  const app2 = new Hono15();
   app2.get("/", async (c) => {
     const projectId = requireValidId(c, "projectId");
     const agentId = requireValidId(c, "agentId");
@@ -3995,7 +4307,7 @@ function benchmarksRoutes(deps2) {
 import fs7 from "fs/promises";
 import path6 from "path";
 import { unzipSync, strFromU8, zipSync } from "fflate";
-import { Hono as Hono13 } from "hono";
+import { Hono as Hono16 } from "hono";
 import {
   installSkill,
   listInstalledSkills,
@@ -4142,12 +4454,12 @@ function parseInstallNames(body) {
   });
 }
 function skillLibraryRoutes() {
-  const app2 = new Hono13();
+  const app2 = new Hono16();
   app2.get("/", (c) => c.json(libraryResponse()));
   return app2;
 }
 function agentSkillsRoutes(deps2) {
-  const app2 = new Hono13();
+  const app2 = new Hono16();
   const listResponse = async (projectId, agentId) => ({
     skills: (await listInstalledSkills(deps2.config.root, projectId, agentId)).map(toMetadataItem)
   });
@@ -4158,6 +4470,17 @@ function agentSkillsRoutes(deps2) {
     await deps2.agentConfigService.requireExists(projectId, agentId);
     return c.json(await listResponse(projectId, agentId));
   });
+  app2.post("/template-placeholder", async (c) => {
+    const projectId = requireValidId(c, "projectId");
+    const agentId = requireValidId(c, "agentId");
+    deps2.projectService.requireProjectAccess(c.var.user.userId, projectId);
+    const view = await deps2.agentConfigService.insertTemplatePlaceholder(
+      projectId,
+      agentId,
+      "skills"
+    );
+    return c.json(view.config.skills);
+  });
   app2.post("/", async (c) => {
     const projectId = requireValidId(c, "projectId");
     const agentId = requireValidId(c, "agentId");
@@ -4195,11 +4518,11 @@ function agentSkillsRoutes(deps2) {
     const skill = parseSkillArchive(archive);
     const dir = path6.join(skillsDir(deps2.config.root, projectId, agentId), skill.name);
     if (!overwrite) {
-      const installed = await fs7.access(path6.join(dir, "SKILL.md")).then(
+      const installed2 = await fs7.access(path6.join(dir, "SKILL.md")).then(
         () => true,
         () => false
       );
-      if (installed) {
+      if (installed2) {
         throw new HttpError(409, "skill_exists", `Skill is already installed: ${skill.name}`);
       }
     }
@@ -4254,10 +4577,10 @@ function agentSkillsRoutes(deps2) {
 
 // src/http/routes/agent-transfer.ts
 import fs8 from "fs/promises";
-import { Hono as Hono14 } from "hono";
+import { Hono as Hono17 } from "hono";
 var MAX_ARCHIVE_BYTES2 = 14 * 1024 * 1024;
 function agentTransferRoutes(deps2) {
-  const app2 = new Hono14();
+  const app2 = new Hono17();
   app2.get("/export", async (c) => {
     const projectId = requireValidId(c, "projectId");
     const agentId = requireValidId(c, "agentId");
@@ -4296,7 +4619,7 @@ function agentTransferRoutes(deps2) {
 }
 
 // src/http/routes/agents.ts
-import { Hono as Hono15 } from "hono";
+import { Hono as Hono18 } from "hono";
 
 // src/http/settle.ts
 async function settleWithin(promises, ms) {
@@ -4310,7 +4633,7 @@ async function settleWithin(promises, ms) {
 // src/http/routes/agents.ts
 var ACTIVITY_DAYS = 30;
 function agentsRoutes(deps2) {
-  const app2 = new Hono15();
+  const app2 = new Hono18();
   app2.get("/", async (c) => {
     const projectId = requireValidId(c, "projectId");
     deps2.projectService.requireProjectAccess(c.var.user.userId, projectId);
@@ -4377,9 +4700,9 @@ function agentsRoutes(deps2) {
 import fs9 from "fs/promises";
 import os from "os";
 import path7 from "path";
-import { Hono as Hono16 } from "hono";
+import { Hono as Hono19 } from "hono";
 function dirsRoutes(deps2) {
-  const app2 = new Hono16();
+  const app2 = new Hono19();
   app2.get("/", async (c) => {
     const projectId = requireValidId(c, "projectId");
     deps2.projectService.requireProjectAccess(c.var.user.userId, projectId);
@@ -4420,9 +4743,14 @@ function dirsRoutes(deps2) {
 }
 
 // src/http/routes/agent-config.ts
-import { Hono as Hono17 } from "hono";
+import { mkdtemp, rm } from "fs/promises";
+import { tmpdir } from "os";
+import { join } from "path";
+import { Hono as Hono20 } from "hono";
+import { McpToolProvider, resolveMCPServer } from "@prismshadow/penguin-core";
+var MCP_TEST_TIMEOUT_CAP_MS = 3e4;
 function agentConfigRoutes(deps2) {
-  const app2 = new Hono17();
+  const app2 = new Hono20();
   app2.get("/", async (c) => {
     const projectId = requireValidId(c, "projectId");
     const agentId = requireValidId(c, "agentId");
@@ -4454,6 +4782,62 @@ function agentConfigRoutes(deps2) {
       activeSessionCount: deps2.manager.activeCountForAgent(projectId, agentId)
     });
   });
+  app2.post("/mcp-test", async (c) => {
+    const projectId = requireValidId(c, "projectId");
+    const agentId = requireValidId(c, "agentId");
+    deps2.projectService.requireProjectAccess(c.var.user.userId, projectId);
+    const body = await readJson(c);
+    if (typeof body.name !== "string" || body.name.length === 0) {
+      throw badRequest("name must be a non-empty string.");
+    }
+    if (body.config === null || typeof body.config !== "object" || Array.isArray(body.config)) {
+      throw badRequest("config must be an object.");
+    }
+    const entry = { name: body.name, config: body.config };
+    let resolved;
+    try {
+      resolved = resolveMCPServer(entry);
+    } catch (err) {
+      throw badRequest(err instanceof Error ? err.message : String(err));
+    }
+    if (resolved.connectTimeoutMs > MCP_TEST_TIMEOUT_CAP_MS) {
+      entry.config = { ...entry.config, connectTimeoutMs: MCP_TEST_TIMEOUT_CAP_MS };
+    }
+    const warnings = [];
+    const workspaceDir = await mkdtemp(join(tmpdir(), "penguin-mcp-test-"));
+    const provider = new McpToolProvider([entry], {
+      workspaceDir,
+      warn: (m) => warnings.push(m)
+    });
+    const startedAt = Date.now();
+    try {
+      const tools = await provider.listTools();
+      const latencyMs = Date.now() - startedAt;
+      const outcome = provider.connectResults()[0];
+      if (outcome === void 0 || outcome.status !== "completed") {
+        return c.json({
+          ok: false,
+          error: outcome?.error ?? (warnings.length > 0 ? warnings.join("; ") : "connect failed"),
+          latencyMs
+        });
+      }
+      return c.json({
+        ok: true,
+        tools: tools.map((t) => t.name),
+        latencyMs
+      });
+    } finally {
+      await provider.close();
+      void rm(workspaceDir, { recursive: true, force: true }).catch(() => void 0);
+    }
+  });
+  app2.post("/kernel-update", async (c) => {
+    const projectId = requireValidId(c, "projectId");
+    const agentId = requireValidId(c, "agentId");
+    deps2.projectService.requireProjectAccess(c.var.user.userId, projectId);
+    const result = await deps2.agentConfigService.kernelUpdate(projectId, agentId);
+    return c.json(result);
+  });
   app2.post("/reset", async (c) => {
     const projectId = requireValidId(c, "projectId");
     const agentId = requireValidId(c, "agentId");
@@ -4469,7 +4853,7 @@ function agentConfigRoutes(deps2) {
 }
 
 // src/http/routes/agent-traces.ts
-import { Hono as Hono18 } from "hono";
+import { Hono as Hono21 } from "hono";
 var MAX_TRACE_BYTES = 14 * 1024 * 1024;
 var SESSION_CATEGORIES2 = [
   "active",
@@ -4478,7 +4862,7 @@ var SESSION_CATEGORIES2 = [
   "archived"
 ];
 function agentTracesRoutes(deps2) {
-  const app2 = new Hono18();
+  const app2 = new Hono21();
   app2.get("/", async (c) => {
     const projectId = requireValidId(c, "projectId");
     const agentId = requireValidId(c, "agentId");
@@ -4556,10 +4940,10 @@ function agentTracesRoutes(deps2) {
 }
 
 // src/http/routes/usage.ts
-import { Hono as Hono19 } from "hono";
+import { Hono as Hono22 } from "hono";
 var GROUP_BYS = ["date", "agent", "model", "session"];
 function usageRoutes(deps2) {
-  const app2 = new Hono19();
+  const app2 = new Hono22();
   app2.get("/", async (c) => {
     const projectId = requireValidId(c, "projectId");
     deps2.projectService.requireProjectAccess(c.var.user.userId, projectId);
@@ -4614,7 +4998,7 @@ function usageRoutes(deps2) {
 // src/http/routes/version.ts
 import { spawn } from "child_process";
 import { BUILD_DATE, VERSION } from "@prismshadow/penguin-core";
-import { Hono as Hono20 } from "hono";
+import { Hono as Hono23 } from "hono";
 var OUTPUT_CAP = 64 * 1024;
 var UPDATE_TIMEOUT_MS = 10 * 60 * 1e3;
 var REFUSAL_MARKERS = [
@@ -4680,7 +5064,7 @@ function runSelfUpdate(cliEntry) {
   });
 }
 function versionRoutes(deps2) {
-  const app2 = new Hono20();
+  const app2 = new Hono23();
   let inflightRun = null;
   app2.get("/", (c) => {
     return c.json({ version: VERSION, buildDate: BUILD_DATE });
@@ -5419,13 +5803,14 @@ function compactUnavailable(why) {
   };
   return new HttpError(409, "nothing_to_compact", messages[why]);
 }
-function createCoreSessionLoader(root, sources) {
+function createCoreSessionLoader(root, sources, opts = {}) {
   return {
     async load(row) {
       const agent = await createAgent({
         root,
         projectId: row.projectId,
-        agentId: row.agentId
+        agentId: row.agentId,
+        ...opts.proxyEnv ? { proxyEnv: opts.proxyEnv } : {}
       });
       const located = await findLatestTraceFile(
         tracesDir(root, row.projectId, row.agentId),
@@ -5570,6 +5955,20 @@ var SessionManager = class {
   liveFragments(sessionId) {
     return this.liveTail.fragments(sessionId);
   }
+  /**
+   * The running Task's input messages as published at launch; empty when idle. The engine
+   * writes these exact envelopes to the Trace only after the first run's bootstrap (MCP
+   * connect + discovery), so GET /messages appends whichever of them the Trace read has
+   * not caught up to yet — without this, a client rebuilding history during the connect
+   * (the draft flow subscribes only after the input publish) loses the user's own message.
+   */
+  pendingInputs(sessionId) {
+    return this.entries.get(sessionId)?.pendingInputs ?? [];
+  }
+  /** The running Task's streamed bootstrap records (see RuntimeEntry.pendingBootstrap); empty when idle. */
+  pendingBootstrap(sessionId) {
+    return this.entries.get(sessionId)?.pendingBootstrap ?? [];
+  }
   /** Number of Sessions for this Agent that are currently running / compacting. */
   activeCountForAgent(projectId, agentId) {
     let n = 0;
@@ -5593,6 +5992,8 @@ var SessionManager = class {
       running: null,
       generation: this.generationOf(row.projectId, row.agentId),
       followUps: [],
+      pendingInputs: [],
+      pendingBootstrap: [],
       pendingSteering: [],
       lastActivityMs: Date.now()
     });
@@ -5696,6 +6097,8 @@ var SessionManager = class {
       entry.status = "running";
       entry.abort = ac;
       entry.lastActivityMs = Date.now();
+      entry.pendingInputs = [...entry.pendingInputs, ...args.input];
+      entry.pendingBootstrap = [];
       this.publishState(entry, "running");
       const approve = makeApprove({
         getMode: () => this.deps.sessions.findById(entry.sessionId)?.approvalMode ?? "always-ask",
@@ -5810,6 +6213,8 @@ var SessionManager = class {
     entry.status = "running";
     entry.abort = ac;
     entry.lastActivityMs = Date.now();
+    entry.pendingInputs = [...entry.pendingInputs, ...input];
+    entry.pendingBootstrap = [];
     for (const msg of input) channel.publish(msg);
     this.publishState(entry, "running");
     const approve = makeApprove({
@@ -5933,6 +6338,34 @@ var SessionManager = class {
     entry.abort.abort();
     return true;
   }
+  /**
+   * Background command processes of a LOADED session (empty when the entry is not in
+   * the active table — a resumed entry starts with a fresh environment and can only
+   * ever report an empty list, so nothing is resurrected just to answer a poll).
+   */
+  listProcesses(sessionId) {
+    return this.entries.get(sessionId)?.session.listBackgroundCommands?.() ?? [];
+  }
+  /** Kills one background command process of a loaded session; false when the session isn't loaded or the id is unknown. */
+  killProcess(sessionId, processId) {
+    const entry = this.entries.get(sessionId);
+    if (!entry) return false;
+    const killed = entry.session.killBackgroundCommand?.(processId) ?? false;
+    if (killed) entry.lastActivityMs = Date.now();
+    return killed;
+  }
+  /**
+   * Disposes a just-removed entry's runtime — after its in-flight drive (if any)
+   * settles, so interrupt cleanup never races a dying environment. Deleting a Session /
+   * Agent / Project is the one intent that must also end the background processes the
+   * conversation started (a dev server surviving its deleted conversation is
+   * unreachable from every UI, running forever).
+   */
+  disposeRemoved(entry) {
+    const dispose = () => entry.session.dispose?.();
+    if (entry.running) void entry.running.then(dispose, dispose);
+    else dispose();
+  }
   /**
    * Before deleting a Project, converge all its active runs and clear them out of the
    * active table. Returns the in-flight drive Promises of the affected entries: the
@@ -5947,6 +6380,7 @@ var SessionManager = class {
       entry.abort?.abort();
       if (entry.running) runnings.push(entry.running);
       this.entries.delete(key);
+      this.disposeRemoved(entry);
     }
     return runnings;
   }
@@ -5968,6 +6402,7 @@ var SessionManager = class {
       entry.abort?.abort();
       if (entry.running) runnings.push(entry.running);
       this.entries.delete(key);
+      this.disposeRemoved(entry);
     }
     return runnings;
   }
@@ -5992,6 +6427,7 @@ var SessionManager = class {
     entry.approvals.denyAll();
     entry.abort?.abort();
     this.entries.delete(sessionId);
+    this.disposeRemoved(entry);
     return entry.running ? [entry.running] : [];
   }
   endSessionDeletion(sessionId) {
@@ -6027,6 +6463,7 @@ var SessionManager = class {
     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 (entry.session.listBackgroundCommands?.().some((p) => p.running)) continue;
       if (now - entry.lastActivityMs <= idleMs) continue;
       this.entries.delete(key);
     }
@@ -6119,6 +6556,8 @@ var SessionManager = class {
       running: null,
       generation,
       followUps: [],
+      pendingInputs: [],
+      pendingBootstrap: [],
       pendingSteering: [],
       lastActivityMs: Date.now()
     };
@@ -6202,6 +6641,16 @@ var SessionManager = class {
             }
           }
         }
+        if (!msg.origin || msg.origin.length === 0) {
+          const bt = msg.payload.type;
+          if (bt === "mcp_connect_begin" || bt === "mcp_connect_end" || bt === "tool_list_ready") {
+            entry.pendingBootstrap.push(msg);
+          }
+          if (bt === "request_begin") {
+            entry.pendingInputs = [];
+            entry.pendingBootstrap = [];
+          }
+        }
         this.liveTail.observe(entry.sessionId, msg);
         this.deps.channels.get(entry.sessionId).publish(msg);
         watcher?.observe(msg);
@@ -6849,6 +7298,7 @@ var AdminService = class {
     }
     this.deps.users.updatePassword(userId, await hashPassword(password), true);
     this.deps.authSessions.deleteByUser(userId);
+    this.deps.onPasswordChanged?.(userId);
   }
   /** Delete user: the built-in admin cannot be deleted; owned Projects (including data directories) are deleted along with it. */
   async deleteUser(userId) {
@@ -6900,36 +7350,34 @@ var DesktopService = class {
   }
 };
 
-// src/http/routes/desktop.ts
-import { Hono as Hono21 } from "hono";
-var SHUTDOWN_DELAY_MS = 50;
-function desktopRoutes(deps2) {
-  const app2 = new Hono21();
-  app2.post("/shutdown", (c) => {
-    const desktop = deps2.desktop;
-    if (!desktop) throw new HttpError(404, "not_found", "Desktop mode is not enabled.");
-    const header = c.req.header("authorization") ?? "";
-    const token = header.startsWith("Bearer ") ? header.slice("Bearer ".length) : "";
-    if (token === "" || !desktop.verifyToken(token)) {
-      throw new HttpError(401, "unauthorized", "Invalid desktop token.");
-    }
-    setTimeout(() => desktop.requestShutdown(), SHUTDOWN_DELAY_MS).unref();
-    return c.body(null, 202);
-  });
-  return app2;
-}
-
 // src/services/agent-config-service.ts
 import fs13 from "fs/promises";
 import { parseDocument, parse as parseYaml } from "yaml";
 import {
+  DEFAULT_MEMORY_PROMPT,
+  DEFAULT_MEMORY_WORKSPACE_PROMPT,
+  DEFAULT_SCHEDULES_PROMPT,
+  DEFAULT_SKILLS_PROMPT,
+  DEFAULT_VAULT_PROMPT,
+  KERNEL_VERSION,
+  LEGACY_SKILLS_SECTION,
+  LEGACY_VAULT_SECTION,
   agentsMdPath,
+  applyKernelUpdate,
+  isKernelOutdated,
   agentStateDir,
   agentStateVersion,
+  hasSchedulesPlaceholder,
+  hasSkillsPlaceholder,
+  hasVaultPlaceholder,
+  insertSchedulesPlaceholder,
+  insertSkillsPlaceholder,
+  insertVaultPlaceholder,
   VAULT_VALUE_MAX_LENGTH,
   isValidVaultKey,
   loadAgentVault,
   resetSystemConfigToDefaults,
+  resolveMCPServer as resolveMCPServer2,
   saveAgentVault,
   systemConfigPath
 } from "@prismshadow/penguin-core";
@@ -7530,10 +7978,13 @@ var AgentConfigService = class {
         ...typeof parsed.name === "string" ? { name: parsed.name } : {},
         ...typeof parsed.description === "string" ? { description: parsed.description } : {},
         toolCount: countOf(tools.builtin) + countOf(tools.mcpServers),
-        version: agentStateVersion({ version: parsed.version })
+        version: agentStateVersion({ version: parsed.version }),
+        kernelOutdated: isKernelOutdated(
+          typeof parsed.kernel_version === "string" ? parsed.kernel_version : null
+        )
       };
     } catch {
-      return { toolCount: 0, version: 1 };
+      return { toolCount: 0, version: 1, kernelOutdated: true };
     }
   }
   /** Structured config view (matching the edit form's shape) + raw text + AGENTS.md + State path. */
@@ -7544,6 +7995,10 @@ var AgentConfigService = class {
     const parsed = asRecord(parseYaml(systemConfigYaml));
     const model = asRecord(parsed.model);
     const compaction = asRecord(parsed.compaction);
+    const memory = asRecord(parsed.memory);
+    const vault = asRecord(parsed.vault);
+    const skills = asRecord(parsed.skills);
+    const schedules = asRecord(parsed.schedules);
     const tools = asRecord(parsed.tools);
     let agentsMd = "";
     try {
@@ -7561,14 +8016,45 @@ var AgentConfigService = class {
       ...compaction.mode === "summarize" || compaction.mode === "discard" ? { mode: compaction.mode } : {},
       ...typeof compaction.prompt === "string" ? { prompt: compaction.prompt } : {}
     };
+    const memoryDto = {
+      enabled: memory.enabled !== false,
+      prompt: typeof memory.prompt === "string" ? memory.prompt : DEFAULT_MEMORY_PROMPT,
+      workspacePrompt: typeof memory.workspace_prompt === "string" ? memory.workspace_prompt : DEFAULT_MEMORY_WORKSPACE_PROMPT
+    };
+    const systemPrompt = typeof parsed.system_prompt === "string" ? parsed.system_prompt : "";
+    const vaultDto = {
+      enabled: vault.enabled !== false,
+      prompt: typeof vault.prompt === "string" ? vault.prompt : DEFAULT_VAULT_PROMPT,
+      templateHasPlaceholder: hasVaultPlaceholder(systemPrompt),
+      legacySectionPresent: systemPrompt.includes(LEGACY_VAULT_SECTION)
+    };
+    const skillsDto = {
+      enabled: skills.enabled !== false,
+      prompt: typeof skills.prompt === "string" ? skills.prompt : DEFAULT_SKILLS_PROMPT,
+      templateHasPlaceholder: hasSkillsPlaceholder(systemPrompt),
+      legacySectionPresent: systemPrompt.includes(LEGACY_SKILLS_SECTION)
+    };
+    const schedulesDto = {
+      enabled: schedules.enabled !== false,
+      prompt: typeof schedules.prompt === "string" ? schedules.prompt : DEFAULT_SCHEDULES_PROMPT,
+      templateHasPlaceholder: hasSchedulesPlaceholder(systemPrompt)
+    };
+    const kernelVersion = typeof parsed.kernel_version === "string" ? parsed.kernel_version : null;
     const config2 = {
       ...typeof parsed.name === "string" ? { name: parsed.name } : {},
       ...typeof parsed.description === "string" ? { description: parsed.description } : {},
       version: agentStateVersion({ version: parsed.version }),
-      systemPrompt: typeof parsed.system_prompt === "string" ? parsed.system_prompt : "",
+      kernelVersion,
+      kernelLatest: KERNEL_VERSION,
+      kernelOutdated: isKernelOutdated(kernelVersion),
+      systemPrompt,
       ...typeof parsed.max_turns === "number" ? { maxTurns: parsed.max_turns } : {},
       ...Object.keys(modelDto).length > 0 ? { model: modelDto } : {},
       ...Object.keys(compactionDto).length > 0 ? { compaction: compactionDto } : {},
+      memory: memoryDto,
+      vault: vaultDto,
+      skills: skillsDto,
+      schedules: schedulesDto,
       toolsBuiltin: Array.isArray(tools.builtin) ? tools.builtin : [],
       mcpServers: Array.isArray(tools.mcpServers) ? tools.mcpServers : []
     };
@@ -7605,12 +8091,22 @@ var AgentConfigService = class {
     await this.requireExists(projectId, agentId);
     await resetSystemConfigToDefaults(this.root, projectId, agentId);
   }
+  /**
+   * Smart-merges the config up to the current defaults generation (core's applyKernelUpdate):
+   * leaves still carrying a recorded generation's default follow the new defaults, user
+   * customizations are kept and reported; the config is stamped with the new kernel version.
+   * The destructive full-refresh alternative stays resetConfig.
+   */
+  async kernelUpdate(projectId, agentId) {
+    await this.requireExists(projectId, agentId);
+    return applyKernelUpdate(this.root, projectId, agentId);
+  }
   async applyConfigUpdate(projectId, agentId, config2) {
     const cfg = config2;
     const yamlPath = systemConfigPath(this.root, projectId, agentId);
     const doc = parseDocument(await fs13.readFile(yamlPath, "utf8"));
-    const setIfProvided = (path19, value) => {
-      if (value !== void 0) doc.setIn(path19, value);
+    const setIfProvided = (path20, value) => {
+      if (value !== void 0) doc.setIn(path20, value);
     };
     setIfProvided(["name"], optionalString(cfg, "name", { maxLen: 100, label: "name" }));
     setIfProvided(
@@ -7653,6 +8149,27 @@ var AgentConfigService = class {
       setIfProvided(["compaction", "mode"], optionalEnum(compaction, "mode", COMPACTION_MODES));
       setIfProvided(["compaction", "prompt"], optionalString(compaction, "prompt"));
     }
+    if (cfg.memory !== void 0) {
+      const memory = asRecord(cfg.memory);
+      setIfProvided(["memory", "enabled"], optionalBoolean(memory, "enabled"));
+      setIfProvided(["memory", "prompt"], optionalString(memory, "prompt"));
+      setIfProvided(["memory", "workspace_prompt"], optionalString(memory, "workspacePrompt"));
+    }
+    if (cfg.vault !== void 0) {
+      const vault = asRecord(cfg.vault);
+      setIfProvided(["vault", "enabled"], optionalBoolean(vault, "enabled"));
+      setIfProvided(["vault", "prompt"], optionalString(vault, "prompt"));
+    }
+    if (cfg.skills !== void 0) {
+      const skills = asRecord(cfg.skills);
+      setIfProvided(["skills", "enabled"], optionalBoolean(skills, "enabled"));
+      setIfProvided(["skills", "prompt"], optionalString(skills, "prompt"));
+    }
+    if (cfg.schedules !== void 0) {
+      const schedules = asRecord(cfg.schedules);
+      setIfProvided(["schedules", "enabled"], optionalBoolean(schedules, "enabled"));
+      setIfProvided(["schedules", "prompt"], optionalString(schedules, "prompt"));
+    }
     if (cfg.toolsBuiltin !== void 0) {
       doc.setIn(["tools", "builtin"], validateToolsBuiltin(cfg.toolsBuiltin));
     }
@@ -7661,6 +8178,26 @@ var AgentConfigService = class {
     }
     await fs13.writeFile(yamlPath, doc.toString(), "utf8");
   }
+  /**
+   * Inserts a feature's section placeholder into the Agent's prompt template — the explicit
+   * adoption path mirroring the Memory tab's endpoint; nothing ever inserts automatically.
+   * For skills/vault the insert is migration-first (core's helpers): a stored template still
+   * carrying the legacy hardcoded section verbatim gets it replaced in place by the
+   * placeholder, otherwise the placeholder is inserted before `# Environment`. Idempotent;
+   * returns the refreshed config view (the route picks out the feature's DTO).
+   */
+  async insertTemplatePlaceholder(projectId, agentId, feature) {
+    const view = await this.getConfig(projectId, agentId);
+    const insert = {
+      vault: insertVaultPlaceholder,
+      skills: insertSkillsPlaceholder,
+      schedules: insertSchedulesPlaceholder
+    }[feature];
+    const next = insert(view.config.systemPrompt);
+    if (next === view.config.systemPrompt) return view;
+    await this.updateConfig(projectId, agentId, { config: { systemPrompt: next } });
+    return this.getConfig(projectId, agentId);
+  }
   /** Read the Agent vault (agent_state/.vault.toml): values are always masked, plaintext is never sent to the client. */
   async getVault(projectId, agentId) {
     await this.requireExists(projectId, agentId);
@@ -7743,6 +8280,7 @@ function validateToolsBuiltin(value) {
 }
 function validateMcpServers(value) {
   if (!Array.isArray(value)) throw badRequest("mcpServers must be an array.");
+  const seen = /* @__PURE__ */ new Set();
   return value.map((item, i) => {
     const s = asRecord(item);
     if (typeof s.name !== "string" || s.name.length === 0) {
@@ -7751,13 +8289,273 @@ function validateMcpServers(value) {
     if (s.config === null || typeof s.config !== "object" || Array.isArray(s.config)) {
       throw badRequest(`mcpServers[${i}].config must be an object.`);
     }
+    try {
+      resolveMCPServer2(s);
+    } catch (err) {
+      throw badRequest(`mcpServers[${i}]: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (seen.has(s.name)) {
+      throw badRequest(`mcpServers[${i}]: duplicate server name "${s.name}".`);
+    }
+    seen.add(s.name);
     return s;
   });
 }
 
-// src/services/agent-service.ts
+// src/services/memory-service.ts
 import fs14 from "fs/promises";
 import path11 from "path";
+import {
+  MEMORY_INDEX_FILENAME,
+  USER_SCOPE_KEY,
+  hasMemoryPlaceholder,
+  insertMemoryPlaceholder,
+  memoryDir,
+  memoryScopeDir,
+  parseMemoryFrontmatter,
+  readWorkspaceMarker
+} from "@prismshadow/penguin-core";
+var SCOPE_KEY_PATTERN = /^[A-Za-z0-9_][A-Za-z0-9._-]*$/;
+function isTopicFileName(name) {
+  return name.length > 0 && !name.startsWith(".") && !/[/\\]/.test(name) && name.toLowerCase().endsWith(".md") && name.toLowerCase() !== MEMORY_INDEX_FILENAME.toLowerCase();
+}
+var MemoryService = class {
+  constructor(root, agentConfigService) {
+    this.root = root;
+    this.agentConfigService = agentConfigService;
+  }
+  root;
+  agentConfigService;
+  /** The tab's landing payload: the Agent-level switch and one entry per scope directory. */
+  async overview(projectId, agentId) {
+    const view = await this.agentConfigService.getConfig(projectId, agentId);
+    return {
+      enabled: view.config.memory.enabled,
+      templateHasMemory: hasMemoryPlaceholder(view.config.systemPrompt),
+      memoryDir: memoryDir(this.root, projectId, agentId),
+      scopes: await this.listScopes(projectId, agentId)
+    };
+  }
+  /**
+   * Inserts the `{{MEMORY}}` placeholder into the Agent's prompt template — the explicit
+   * adoption path for an Agent created before Memory shipped; nothing inserts automatically.
+   * Idempotent: a template that already carries it is left as it is (the refreshed overview
+   * reports `templateHasMemory` either way).
+   */
+  async insertTemplatePlaceholder(projectId, agentId) {
+    const view = await this.agentConfigService.getConfig(projectId, agentId);
+    const next = insertMemoryPlaceholder(view.config.systemPrompt);
+    if (next !== view.config.systemPrompt) {
+      await this.agentConfigService.updateConfig(projectId, agentId, {
+        config: { systemPrompt: next }
+      });
+    }
+    return this.overview(projectId, agentId);
+  }
+  /**
+   * The scope directories under `memory/`: the User scope first — always listed, even before it
+   * exists on disk, so a memory can be filed there without waiting for a Session to create it —
+   * then the Workspaces, newest activity first (one with no topic file yet sorts last, by key).
+   */
+  async listScopes(projectId, agentId) {
+    const base = memoryDir(this.root, projectId, agentId);
+    let entries = [];
+    try {
+      entries = (await fs14.readdir(base, { withFileTypes: true })).filter((e) => e.isDirectory() && e.name !== USER_SCOPE_KEY).map((e) => e.name);
+    } catch {
+    }
+    const workspaces = await Promise.all(
+      entries.map((key) => this.scopeInfo(path11.join(base, key), key, "workspace"))
+    );
+    workspaces.sort((a, b) => {
+      if (a.updatedAt && b.updatedAt) return b.updatedAt.localeCompare(a.updatedAt);
+      if (a.updatedAt) return -1;
+      if (b.updatedAt) return 1;
+      return a.scopeKey.localeCompare(b.scopeKey);
+    });
+    const userScope = await this.scopeInfo(path11.join(base, USER_SCOPE_KEY), USER_SCOPE_KEY, "user");
+    return [userScope, ...workspaces];
+  }
+  async scopeInfo(dir, key, kind) {
+    const files = await this.topicFileNames(dir);
+    let latest = 0;
+    for (const name of files) {
+      try {
+        const stat = await fs14.stat(path11.join(dir, name));
+        latest = Math.max(latest, stat.mtimeMs);
+      } catch {
+      }
+    }
+    const workspacePath = kind === "workspace" ? await readWorkspaceMarker(dir) : void 0;
+    return {
+      scopeKey: key,
+      kind,
+      ...workspacePath !== void 0 ? { workspacePath } : {},
+      fileCount: files.length,
+      ...latest > 0 ? { updatedAt: new Date(latest).toISOString() } : {}
+    };
+  }
+  /** Topic files of one scope: regular Markdown files only — the index, the `.workspace` marker, stray directories and symlinks (dirents that are not regular files) all stay out. */
+  async topicFileNames(dir) {
+    try {
+      return (await fs14.readdir(dir, { withFileTypes: true })).filter((e) => e.isFile() && isTopicFileName(e.name)).map((e) => e.name).sort((a, b) => a.localeCompare(b));
+    } catch {
+      return [];
+    }
+  }
+  async listFiles(projectId, agentId, scopeKey) {
+    const dir = await this.requireScopeDir(projectId, agentId, scopeKey);
+    const names = await this.topicFileNames(dir);
+    const files = [];
+    for (const name of names) {
+      const info = await this.fileInfo(dir, name);
+      if (info) files.push(info);
+    }
+    return { scopeKey, files };
+  }
+  async readFile(projectId, agentId, scopeKey, fileName) {
+    const dir = await this.requireScopeDir(projectId, agentId, scopeKey);
+    const target = this.resolveFile(dir, fileName);
+    try {
+      const stat = await fs14.lstat(target);
+      if (!stat.isFile()) throw new Error("not a regular file");
+      const content = await fs14.readFile(target, "utf8");
+      return {
+        scopeKey,
+        file: this.describe(fileName, content, stat.size, stat.mtime),
+        content
+      };
+    } catch {
+      throw new HttpError(404, "memory_file_not_found", `Memory file not found: ${fileName}`);
+    }
+  }
+  /**
+   * Deletes a topic file and mechanically drops its lines from the scope's `MEMORY.md`: any
+   * line whose Markdown link target is exactly this file (`](<file>)`) goes; a mention of the
+   * name in ordinary prose, or a link to a different file, survives. This is the only write the
+   * API performs on Memory content — everything else is the model's, through a chat Session.
+   */
+  async deleteFile(projectId, agentId, scopeKey, fileName) {
+    const dir = await this.requireScopeDir(projectId, agentId, scopeKey);
+    const target = this.resolveFile(dir, fileName);
+    try {
+      await fs14.unlink(target);
+    } catch {
+      throw new HttpError(404, "memory_file_not_found", `Memory file not found: ${fileName}`);
+    }
+    await this.pruneIndexLines(dir, fileName);
+  }
+  /** Removes index lines linking to a deleted file. Best-effort: a missing or unreadable index is left alone. */
+  async pruneIndexLines(dir, fileName) {
+    const indexPath = path11.join(dir, MEMORY_INDEX_FILENAME);
+    let content;
+    try {
+      content = await fs14.readFile(indexPath, "utf8");
+    } catch {
+      return;
+    }
+    const escaped = fileName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const link = new RegExp(`\\]\\(\\s*<?(?:\\./)?${escaped}>?\\s*(?:"[^"]*"\\s*)?\\)`);
+    const lines = content.split("\n");
+    const kept = lines.filter((line) => !link.test(line));
+    if (kept.length === lines.length) return;
+    await fs14.writeFile(indexPath, kept.join("\n"), "utf8");
+  }
+  async fileInfo(dir, name) {
+    try {
+      const [content, stat] = await Promise.all([
+        fs14.readFile(path11.join(dir, name), "utf8"),
+        fs14.stat(path11.join(dir, name))
+      ]);
+      return this.describe(name, content, stat.size, stat.mtime);
+    } catch {
+      return null;
+    }
+  }
+  /** One listing entry: frontmatter (falling back to the file name for an unparsed file) plus file stats. */
+  describe(name, content, size, mtime) {
+    const meta = parseMemoryFrontmatter(content, name);
+    return {
+      name,
+      title: meta?.name ?? name,
+      description: meta?.description ?? "",
+      ...meta?.updatedAt !== void 0 ? { updatedAt: meta.updatedAt } : {},
+      size,
+      modifiedAt: mtime.toISOString()
+    };
+  }
+  /**
+   * Validates a scope key and returns its directory, 404 if it does not exist. The key is only
+   * ever a single directory name.
+   *
+   * A Workspace directory is created by a Session, so this API never creates one — a key with no
+   * directory means no Session has run there and there is nothing to list. The User scope is the
+   * exception: it belongs to the Agent rather than to any Session, so it is created on demand
+   * (Agents that predate Memory have no `memory/user/` until their next Session).
+   */
+  async requireScopeDir(projectId, agentId, scopeKey) {
+    await this.agentConfigService.requireExists(projectId, agentId);
+    if (!SCOPE_KEY_PATTERN.test(scopeKey)) {
+      throw badRequest("scopeKey is invalid.");
+    }
+    const dir = memoryScopeDir(this.root, projectId, agentId, scopeKey);
+    if (scopeKey === USER_SCOPE_KEY) {
+      await fs14.mkdir(dir, { recursive: true });
+      return this.requireRealScopeDir(projectId, agentId, scopeKey, dir);
+    }
+    try {
+      if ((await fs14.stat(dir)).isDirectory()) {
+        return this.requireRealScopeDir(projectId, agentId, scopeKey, dir);
+      }
+    } catch {
+    }
+    throw new HttpError(
+      404,
+      "memory_scope_not_found",
+      `No Memory directory for scope: ${scopeKey}`
+    );
+  }
+  /**
+   * Symlink hardening for the scope directory itself: a scope smuggled in as a symlink (the
+   * model can create one with its file tools) would carry every read and delete outside
+   * `memory/`, so the resolved real path must be exactly `<real memory/>/<scopeKey>` — not a
+   * link's target, wherever it points.
+   */
+  async requireRealScopeDir(projectId, agentId, scopeKey, dir) {
+    try {
+      const realBase = await fs14.realpath(memoryDir(this.root, projectId, agentId));
+      if (await fs14.realpath(dir) === path11.join(realBase, scopeKey)) return dir;
+    } catch {
+    }
+    throw new HttpError(
+      404,
+      "memory_scope_not_found",
+      `No Memory directory for scope: ${scopeKey}`
+    );
+  }
+  /**
+   * The absolute path of a topic file inside a scope directory. The name must pass the
+   * character rule, must not be the reserved index name, and the joined path is checked
+   * for containment — belt and braces, since the rule already excludes separators.
+   */
+  resolveFile(dir, fileName) {
+    if (!isTopicFileName(fileName)) {
+      throw badRequest(
+        `File name must be a Markdown topic file \u2014 no path, no leading dot, and not the ${MEMORY_INDEX_FILENAME} index.`
+      );
+    }
+    const target = path11.join(dir, fileName);
+    const rel = path11.relative(dir, target);
+    if (rel !== fileName || rel.includes(path11.sep)) {
+      throw badRequest("File name must not contain a path.");
+    }
+    return target;
+  }
+};
+
+// src/services/agent-service.ts
+import fs15 from "fs/promises";
+import path12 from "path";
 import {
   agentDir,
   agentsDir as agentsDir2,
@@ -7766,6 +8564,7 @@ import {
   createAgent as coreCreateAgent,
   isValidId as isValidId4,
   loadAgentVault as loadAgentVault2,
+  memoryDir as memoryDir2,
   scheduleDir as scheduleDir2,
   skillsDir as skillsDir2,
   systemConfigPath as systemConfigPath2
@@ -7784,7 +8583,7 @@ var AgentService = class {
     const known = new Map(this.agents.list(projectId).map((r) => [r.agentId, r]));
     let entries = [];
     try {
-      const dirents = await fs14.readdir(agentsDir2(this.root, projectId), { withFileTypes: true });
+      const dirents = await fs15.readdir(agentsDir2(this.root, projectId), { withFileTypes: true });
       entries = dirents.filter((d) => d.isDirectory()).map((d) => d.name);
     } catch {
     }
@@ -7793,7 +8592,7 @@ var AgentService = class {
       const configPath = systemConfigPath2(this.root, projectId, agentId);
       let createdAt;
       try {
-        const stat = await fs14.stat(configPath);
+        const stat = await fs15.stat(configPath);
         createdAt = (stat.birthtime.getTime() > 0 ? stat.birthtime : stat.mtime).toISOString();
       } catch {
         continue;
@@ -7807,12 +8606,13 @@ var AgentService = class {
     );
     return Promise.all(
       sorted.map(async (row) => {
-        const [meta, updatedAt, vaultKeyCount, scheduleCount, skillCount] = await Promise.all([
+        const [meta, updatedAt, vaultKeyCount, scheduleCount, skillCount, memoryCount] = await Promise.all([
           this.agentConfig.readCardMeta(projectId, row.agentId),
           this.configUpdatedAt(projectId, row.agentId),
           this.vaultKeyCount(projectId, row.agentId),
           this.scheduleCount(projectId, row.agentId),
-          this.skillCount(projectId, row.agentId)
+          this.skillCount(projectId, row.agentId),
+          this.memoryCount(projectId, row.agentId)
         ]);
         return {
           agentId: row.agentId,
@@ -7821,7 +8621,8 @@ var AgentService = class {
           ...updatedAt !== void 0 ? { updatedAt } : {},
           vaultKeyCount,
           scheduleCount,
-          skillCount
+          skillCount,
+          memoryCount
         };
       })
     );
@@ -7837,7 +8638,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 fs14.readdir(scheduleDir2(this.root, projectId, agentId));
+      const names = await fs15.readdir(scheduleDir2(this.root, projectId, agentId));
       return names.filter((n) => n.endsWith(".toml")).length;
     } catch {
       return 0;
@@ -7848,14 +8649,14 @@ var AgentService = class {
     const base = skillsDir2(this.root, projectId, agentId);
     let dirents;
     try {
-      dirents = await fs14.readdir(base, { withFileTypes: true });
+      dirents = await fs15.readdir(base, { withFileTypes: true });
     } catch {
       return 0;
     }
     const present = await Promise.all(
       dirents.filter((d) => d.isDirectory()).map(async (d) => {
         try {
-          await fs14.access(path11.join(base, d.name, "SKILL.md"));
+          await fs15.access(path12.join(base, d.name, "SKILL.md"));
           return true;
         } catch {
           return false;
@@ -7864,6 +8665,27 @@ var AgentService = class {
     );
     return present.filter(Boolean).length;
   }
+  /** Number of memory topic files: regular `*.md` files (minus each scope's MEMORY.md index) summed over the scope directories under memory/ (0 if the directory doesn't exist). */
+  async memoryCount(projectId, agentId) {
+    const base = memoryDir2(this.root, projectId, agentId);
+    let scopes;
+    try {
+      scopes = await fs15.readdir(base, { withFileTypes: true });
+    } catch {
+      return 0;
+    }
+    const counts = await Promise.all(
+      scopes.filter((d) => d.isDirectory()).map(async (d) => {
+        try {
+          const files = await fs15.readdir(path12.join(base, d.name), { withFileTypes: true });
+          return files.filter((f) => f.isFile() && isTopicFileName(f.name)).length;
+        } catch {
+          return 0;
+        }
+      })
+    );
+    return counts.reduce((sum, n) => sum + n, 0);
+  }
   /** Last config modification time: the later of system_config.yaml and AGENTS.md mtime; omitted if neither is readable. */
   async configUpdatedAt(projectId, agentId) {
     const paths = [
@@ -7873,7 +8695,7 @@ var AgentService = class {
     const times = await Promise.all(
       paths.map(async (p) => {
         try {
-          return (await fs14.stat(p)).mtime.getTime();
+          return (await fs15.stat(p)).mtime.getTime();
         } catch {
           return 0;
         }
@@ -7898,7 +8720,7 @@ var AgentService = class {
         "Built-in Agents (default_agent) are provisioned with the Project and cannot be deleted from the web."
       );
     }
-    await fs14.rm(agentDir(this.root, projectId, agentId), { recursive: true, force: true });
+    await fs15.rm(agentDir(this.root, projectId, agentId), { recursive: true, force: true });
     this.agents.delete(projectId, agentId);
   }
   /**
@@ -7915,7 +8737,7 @@ var AgentService = class {
         `Agent id must be 2\u201364 characters: ${SEMANTIC_ID_RULE}.`
       );
     }
-    const taken = this.agents.exists(projectId, agentId) || await fs14.stat(agentDir(this.root, projectId, agentId)).then(
+    const taken = this.agents.exists(projectId, agentId) || await fs15.stat(agentDir(this.root, projectId, agentId)).then(
       () => true,
       () => false
     );
@@ -7929,7 +8751,7 @@ var AgentService = class {
         config: { name: displayName, ...description !== void 0 ? { description } : {} }
       });
     } catch (err) {
-      await fs14.rm(agentDir(this.root, projectId, agentId), { recursive: true, force: true }).catch(() => {
+      await fs15.rm(agentDir(this.root, projectId, agentId), { recursive: true, force: true }).catch(() => {
       });
       throw err;
     }
@@ -7944,17 +8766,19 @@ var AgentService = class {
       updatedAt: createdAt,
       toolCount: meta.toolCount,
       version: meta.version,
+      kernelOutdated: meta.kernelOutdated,
       vaultKeyCount: 0,
       scheduleCount: 0,
       // Read the real count: coreCreateAgent seeds the default skill set for default_agent.
-      skillCount: await this.skillCount(projectId, agentId)
+      skillCount: await this.skillCount(projectId, agentId),
+      memoryCount: 0
     };
   }
 };
 
 // src/services/benchmark-service.ts
-import fs15 from "fs/promises";
-import path12 from "path";
+import fs16 from "fs/promises";
+import path13 from "path";
 import { parse as parseToml3 } from "smol-toml";
 import { parse as parseYaml2 } from "yaml";
 import { benchmarksDir } from "@prismshadow/penguin-core";
@@ -7985,15 +8809,15 @@ 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);
+  const relative = path13.relative(parent, child);
+  return relative !== "" && !relative.startsWith("..") && !path13.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 fs15.open(readme, "r");
+  const handle = await fs16.open(readme, "r");
   try {
     const buffer = Buffer.alloc(STATEMENT_TITLE_READ_BYTES);
     const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
@@ -8075,28 +8899,28 @@ var BenchmarkService = class {
     const dir = benchmarksDir(this.root, projectId, agentId);
     let items;
     try {
-      const entries = await fs15.readdir(dir, { withFileTypes: true });
+      const entries = await fs16.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(path12.join(dir, item.name), item.name));
+      benchmarks.push(await this.readBenchmark(path13.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);
+    const benchDir = path13.join(baseDir, benchmarkId);
     let entries;
     let realBaseDir;
     let realBenchDir;
     try {
       [entries, realBaseDir, realBenchDir] = await Promise.all([
-        fs15.readdir(benchDir, { withFileTypes: true }),
-        fs15.realpath(baseDir),
-        fs15.realpath(benchDir)
+        fs16.readdir(benchDir, { withFileTypes: true }),
+        fs16.realpath(baseDir),
+        fs16.realpath(benchDir)
       ]);
     } catch {
       return { cases: [] };
@@ -8113,7 +8937,7 @@ var BenchmarkService = class {
           entry.name,
           "statement"
         );
-        const realReadme = await fs15.realpath(path12.join(statementDir, "README.md"));
+        const realReadme = await fs16.realpath(path13.join(statementDir, "README.md"));
         if (!isWithin(statementDir, realReadme)) throw new Error("README escapes Statement");
         cases.push({
           id: entry.name,
@@ -8146,16 +8970,16 @@ var BenchmarkService = class {
     return this.workspaceFiles.read(materialRoot, rel, options);
   }
   async caseMaterialRoot(projectId, agentId, benchmarkId, caseId, material) {
-    const benchDir = path12.join(benchmarksDir(this.root, projectId, agentId), benchmarkId);
-    const caseDir = path12.join(benchDir, caseId);
-    const materialRoot = path12.join(caseDir, material);
+    const benchDir = path13.join(benchmarksDir(this.root, projectId, agentId), benchmarkId);
+    const caseDir = path13.join(benchDir, caseId);
+    const materialRoot = path13.join(caseDir, material);
     try {
       const [realBenchDir, realCaseDir, realMaterialRoot] = await Promise.all([
-        fs15.realpath(benchDir),
-        fs15.realpath(caseDir),
-        fs15.realpath(materialRoot)
+        fs16.realpath(benchDir),
+        fs16.realpath(caseDir),
+        fs16.realpath(materialRoot)
       ]);
-      if (!isWithin(realBenchDir, realCaseDir) || path12.dirname(realMaterialRoot) !== realCaseDir || path12.basename(realMaterialRoot) !== material) {
+      if (!isWithin(realBenchDir, realCaseDir) || path13.dirname(realMaterialRoot) !== realCaseDir || path13.basename(realMaterialRoot) !== material) {
         throw new Error("Case material is not canonical");
       }
       return realMaterialRoot;
@@ -8169,7 +8993,7 @@ var BenchmarkService = class {
     let runs;
     try {
       const config2 = asRecord2(
-        parseToml3(await fs15.readFile(path12.join(benchDir, "benchmark_config.toml"), "utf8"))
+        parseToml3(await fs16.readFile(path13.join(benchDir, "benchmark_config.toml"), "utf8"))
       );
       if (typeof config2.title === "string" && config2.title !== "") title = config2.title;
       if (typeof config2.description === "string" && config2.description !== "") {
@@ -8184,7 +9008,7 @@ var BenchmarkService = class {
     let evaluations = [];
     try {
       const scoreboard = asRecord2(
-        parseYaml2(await fs15.readFile(path12.join(benchDir, "scoreboard.yaml"), "utf8"))
+        parseYaml2(await fs16.readFile(path13.join(benchDir, "scoreboard.yaml"), "utf8"))
       );
       if (Array.isArray(scoreboard.evaluations)) {
         evaluations = scoreboard.evaluations.map(toEvaluation).filter((e) => e !== null);
@@ -8193,7 +9017,7 @@ var BenchmarkService = class {
     }
     let caseCount = 0;
     try {
-      const entries = await fs15.readdir(benchDir, { withFileTypes: true });
+      const entries = await fs16.readdir(benchDir, { withFileTypes: true });
       caseCount = entries.filter((e) => e.isDirectory() && e.name.startsWith("CASE-")).length;
     } catch {
     }
@@ -8210,8 +9034,8 @@ var BenchmarkService = class {
 
 // src/services/snapshot-service.ts
 import { randomBytes as randomBytes6 } from "crypto";
-import fs16 from "fs/promises";
-import path13 from "path";
+import fs17 from "fs/promises";
+import path14 from "path";
 import * as tar from "tar";
 import { parse as parseYaml3 } from "yaml";
 import {
@@ -8224,7 +9048,7 @@ import {
 } from "@prismshadow/penguin-core";
 var VAULT_BASENAME = ".vault.toml";
 function isVaultEntry(entryPath) {
-  return path13.posix.basename(entryPath.replaceAll("\\", "/")) === VAULT_BASENAME;
+  return path14.posix.basename(entryPath.replaceAll("\\", "/")) === VAULT_BASENAME;
 }
 var SnapshotService = class {
   constructor(root) {
@@ -8235,7 +9059,7 @@ var SnapshotService = class {
   async currentVersion(projectId, agentId) {
     let raw;
     try {
-      raw = await fs16.readFile(systemConfigPath3(this.root, projectId, agentId), "utf8");
+      raw = await fs17.readFile(systemConfigPath3(this.root, projectId, agentId), "utf8");
     } catch {
       throw new HttpError(404, "agent_not_found", "Agent does not exist.");
     }
@@ -8248,13 +9072,13 @@ var SnapshotService = class {
   async ensureSnapshot(projectId, agentId) {
     const version = await this.currentVersion(projectId, agentId);
     const dir = snapshotsDir(this.root, projectId, agentId);
-    const file = path13.join(dir, `v${version}.tar.gz`);
+    const file = path14.join(dir, `v${version}.tar.gz`);
     try {
-      await fs16.access(file);
+      await fs17.access(file);
       return { version, file };
     } catch {
     }
-    await fs16.mkdir(dir, { recursive: true });
+    await fs17.mkdir(dir, { recursive: true });
     const tmp = `${file}.tmp-${randomBytes6(4).toString("hex")}`;
     await tar.create(
       {
@@ -8266,7 +9090,7 @@ var SnapshotService = class {
       },
       ["agent_state"]
     );
-    await fs16.rename(tmp, file);
+    await fs17.rename(tmp, file);
     return { version, file };
   }
   /** Export: automatically packs a snapshot first if none exists, returns the info needed for download. */
@@ -8281,15 +9105,15 @@ var SnapshotService = class {
    * replaces `agent_state/` while keeping the current vault.
    */
   async importArchive(projectId, agentId, archive, confirm) {
-    const current = await this.currentVersion(projectId, agentId);
+    const current2 = await this.currentVersion(projectId, agentId);
     const base = agentDir2(this.root, projectId, agentId);
-    const staging = path13.join(base, `.import-${randomBytes6(6).toString("hex")}`);
-    await fs16.mkdir(staging, { recursive: true });
+    const staging = path14.join(base, `.import-${randomBytes6(6).toString("hex")}`);
+    await fs17.mkdir(staging, { recursive: true });
     try {
-      const archiveFile = path13.join(staging, "archive.tar.gz");
-      await fs16.writeFile(archiveFile, archive);
-      const extractDir = path13.join(staging, "extracted");
-      await fs16.mkdir(extractDir, { recursive: true });
+      const archiveFile = path14.join(staging, "archive.tar.gz");
+      await fs17.writeFile(archiveFile, archive);
+      const extractDir = path14.join(staging, "extracted");
+      await fs17.mkdir(extractDir, { recursive: true });
       try {
         await tar.extract({
           file: archiveFile,
@@ -8299,10 +9123,10 @@ var SnapshotService = class {
       } catch {
         throw badRequest("Import failed: not a valid tar.gz snapshot package.");
       }
-      const configPath = path13.join(extractDir, "agent_state", "system_config.yaml");
+      const configPath = path14.join(extractDir, "agent_state", "system_config.yaml");
       let parsed;
       try {
-        parsed = parseYaml3(await fs16.readFile(configPath, "utf8"));
+        parsed = parseYaml3(await fs17.readFile(configPath, "utf8"));
       } catch {
         throw badRequest("Import failed: the package is missing agent_state/system_config.yaml.");
       }
@@ -8316,46 +9140,46 @@ var SnapshotService = class {
       const incoming = agentStateVersion2({
         version: typeof incomingRaw === "number" ? incomingRaw : void 0
       });
-      if (incoming <= current && !confirm) {
+      if (incoming <= current2 && !confirm) {
         throw new HttpError(
           409,
           "version_conflict",
-          `Package version v${incoming} is not higher than the current v${current}; confirmation is required to import.`
+          `Package version v${incoming} is not higher than the current v${current2}; confirmation is required to import.`
         );
       }
       await this.ensureSnapshot(projectId, agentId);
       const stateDir = agentStateDir2(this.root, projectId, agentId);
-      const incomingState = path13.join(extractDir, "agent_state");
+      const incomingState = path14.join(extractDir, "agent_state");
       let vault = null;
       try {
-        vault = await fs16.readFile(agentVaultPath(this.root, projectId, agentId));
+        vault = await fs17.readFile(agentVaultPath(this.root, projectId, agentId));
       } catch {
       }
       if (vault !== null) {
-        await fs16.writeFile(path13.join(incomingState, VAULT_BASENAME), vault, { mode: 384 });
+        await fs17.writeFile(path14.join(incomingState, VAULT_BASENAME), vault, { mode: 384 });
       }
-      const trash = path13.join(staging, "replaced-agent_state");
-      await fs16.rename(stateDir, trash);
+      const trash = path14.join(staging, "replaced-agent_state");
+      await fs17.rename(stateDir, trash);
       try {
-        await fs16.rename(incomingState, stateDir);
+        await fs17.rename(incomingState, stateDir);
       } catch (err) {
-        await fs16.rename(trash, stateDir);
+        await fs17.rename(trash, stateDir);
         throw err;
       }
       return { version: incoming };
     } finally {
-      await fs16.rm(staging, { recursive: true, force: true });
+      await fs17.rm(staging, { recursive: true, force: true });
     }
   }
 };
 
 // src/services/project-service.ts
-import fs17 from "fs/promises";
+import fs18 from "fs/promises";
 import { DEFAULT_PROJECT_ID, projectDir, provisionProjectAgents } from "@prismshadow/penguin-core";
 var ABORT_SETTLE_TIMEOUT_MS = 5e3;
-async function dirExists(path19) {
+async function dirExists(path20) {
   try {
-    const stat = await fs17.stat(path19);
+    const stat = await fs18.stat(path20);
     return stat.isDirectory();
   } catch {
     return false;
@@ -8480,12 +9304,12 @@ var ProjectService = class {
       throw err;
     }
     try {
-      await fs17.mkdir(projectDir(this.deps.root, projectId), { recursive: true });
+      await fs18.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 fs17.rm(projectDir(this.deps.root, projectId), { recursive: true, force: true }).catch(() => {
+      await fs18.rm(projectDir(this.deps.root, projectId), { recursive: true, force: true }).catch(() => {
       });
       throw err;
     }
@@ -8584,7 +9408,7 @@ var ProjectService = class {
     this.deps.schedules.deleteByProject(projectId);
     this.deps.goals.deleteByProject(projectId);
     this.deps.traceIndex.removeProject(projectId);
-    await fs17.rm(projectDir(this.deps.root, projectId), { recursive: true, force: true });
+    await fs18.rm(projectDir(this.deps.root, projectId), { recursive: true, force: true });
   }
   // —— Member authorization ——
   /** Member list: owner (role=owner) + members. */
@@ -8658,8 +9482,8 @@ var ProjectService = class {
 import { createAgent as createAgent2, isSessionMeta as isSessionMeta5 } from "@prismshadow/penguin-core";
 
 // src/services/trace-index.ts
-import fs18 from "fs/promises";
-import path14 from "path";
+import fs19 from "fs/promises";
+import path15 from "path";
 import { agentsDir as agentsDir3, isSessionMeta as isSessionMeta4, tracesDir as tracesDir2 } from "@prismshadow/penguin-core";
 
 // src/internal/trace-head.ts
@@ -8692,11 +9516,11 @@ async function readTraceHead(filePath) {
 var TRACE_FILE_RE = /^(.+)_(\d{3})\.jsonl$/;
 function traceFilePath(root, row) {
   const name = `${row.sessionId}_${String(row.fileIndex).padStart(3, "0")}.jsonl`;
-  return path14.join(tracesDir2(root, row.projectId, row.agentId), row.date, name);
+  return path15.join(tracesDir2(root, row.projectId, row.agentId), row.date, name);
 }
 async function listDirs(dir) {
   try {
-    const entries = await fs18.readdir(dir, { withFileTypes: true });
+    const entries = await fs19.readdir(dir, { withFileTypes: true });
     return entries.filter((e) => e.isDirectory()).map((e) => e.name);
   } catch {
     return [];
@@ -8704,7 +9528,7 @@ async function listDirs(dir) {
 }
 async function listFiles(dir) {
   try {
-    const entries = await fs18.readdir(dir, { withFileTypes: true });
+    const entries = await fs19.readdir(dir, { withFileTypes: true });
     return entries.filter((e) => e.isFile()).map((e) => e.name);
   } catch {
     return [];
@@ -8789,7 +9613,7 @@ var TraceIndexService = class {
       const newest = [...cached.dates.keys()].sort().at(-1);
       if (newest === void 0) return;
       this.counters.gateStats += 1;
-      const m = await statMtime(path14.join(dir, newest));
+      const m = await statMtime(path15.join(dir, newest));
       if (m !== null && m === cached.dates.get(newest)) return;
     }
     this.counters.dirScans += 1;
@@ -8803,14 +9627,14 @@ var TraceIndexService = class {
     const newSessions = /* @__PURE__ */ new Set();
     const dateDirs = await listDirs(dir);
     for (const date of dateDirs) {
-      const m = await statMtime(path14.join(dir, date));
+      const m = await statMtime(path15.join(dir, date));
       if (m === null) continue;
       next.dates.set(date, cacheable(m));
       if (!force && cached?.dates.get(date) === m) continue;
       const known = new Map(
         (knownByDate.get(date) ?? []).map((r) => [`${r.sessionId}\0${r.fileIndex}`, r])
       );
-      for (const file of await listFiles(path14.join(dir, date))) {
+      for (const file of await listFiles(path15.join(dir, date))) {
         const match = TRACE_FILE_RE.exec(file);
         if (!match) continue;
         const sessionId = match[1];
@@ -8818,7 +9642,7 @@ var TraceIndexService = class {
         const fileKey = `${sessionId}\0${fileIndex}`;
         let size = 0;
         try {
-          size = (await fs18.stat(path14.join(dir, date, file))).size;
+          size = (await fs19.stat(path15.join(dir, date, file))).size;
         } catch {
           continue;
         }
@@ -9113,7 +9937,8 @@ var SessionService = class {
     const agent = await createAgent2({
       root: this.deps.root,
       projectId: args.projectId,
-      agentId: args.agentId
+      agentId: args.agentId,
+      ...this.deps.proxyEnv ? { proxyEnv: this.deps.proxyEnv } : {}
     });
     let session;
     try {
@@ -9230,8 +10055,8 @@ function localDate(d) {
 }
 
 // src/services/trace-service.ts
-import fs19 from "fs/promises";
-import path15 from "path";
+import fs20 from "fs/promises";
+import path16 from "path";
 import {
   isSessionMeta as isSessionMeta6,
   parseTraceLines as parseTraceLines2,
@@ -9277,15 +10102,15 @@ var TraceService = class {
     }));
   }
   /** All shard reads funnel through here (deps.observeShardRead is the windowed-read tests' proof of which files were touched). */
-  async readShard(path19) {
-    this.deps.observeShardRead?.(path19);
-    return readTraceTolerant2(path19);
+  async readShard(path20) {
+    this.deps.observeShardRead?.(path20);
+    return readTraceTolerant2(path20);
   }
   /** Deletes all of this Session's Trace files (called when the Session is deleted); the index rows go with them. */
   async deleteSessionTraces(projectId, agentId, sessionId) {
     const files = await this.locateAll(projectId, agentId, sessionId);
     for (const file of files) {
-      await fs19.rm(file.path, { force: true });
+      await fs20.rm(file.path, { force: true });
     }
     this.deps.index.removeSession(projectId, agentId, sessionId);
   }
@@ -9534,7 +10359,7 @@ var TraceService = class {
     const files = await this.locateAll(projectId, agentId, sessionId);
     const out = [];
     for (const file of files) {
-      const stat = await fs19.stat(file.path);
+      const stat = await fs20.stat(file.path);
       out.push({
         index: file.index,
         date: file.date,
@@ -9566,7 +10391,9 @@ var TraceService = class {
     const usageTrend = [];
     const modelSegments = [];
     const toolSpans = [];
+    const otherSpans = [];
     const openSpansById = /* @__PURE__ */ new Map();
+    let openMcpConnect = null;
     let prevSerialTs = null;
     let taskIndex = -1;
     let continuation = false;
@@ -9665,6 +10492,22 @@ var TraceService = class {
             }
             openRequest = null;
           }
+        } else if (p.type === "mcp_connect_begin") {
+          if (!hasOrigin) openMcpConnect = { beginTs: msg.timestamp };
+        } else if (p.type === "mcp_connect_end") {
+          if (!hasOrigin && openMcpConnect) {
+            const q = p;
+            const failed = q.status !== "completed";
+            otherSpans.push({
+              key: `mcp-connect-${openMcpConnect.beginTs}`,
+              name: "mcp connect",
+              startTs: openMcpConnect.beginTs,
+              endTs: msg.timestamp,
+              taskIndex: taskIndex + 1,
+              ...failed ? { failed: true } : {}
+            });
+            openMcpConnect = null;
+          }
         } else if (p.type === "compaction_begin") {
           compactionCount++;
           if (!hasOrigin) {
@@ -9785,6 +10628,7 @@ var TraceService = class {
       toolCalls,
       modelSegments,
       toolSpans,
+      otherSpans,
       reconnectCount,
       compactionCount,
       usageTrend
@@ -9883,7 +10727,7 @@ var TraceService = class {
         shard.map(async (f) => {
           let sizeBytes = f.sizeBytes;
           try {
-            sizeBytes = (await fs19.stat(traceFilePath(this.root, f))).size;
+            sizeBytes = (await fs20.stat(traceFilePath(this.root, f))).size;
             if (sizeBytes !== f.sizeBytes) {
               this.deps.index.repo.updateFileSize(
                 projectId,
@@ -9929,7 +10773,7 @@ var TraceService = class {
   /** Raw bytes of the Trace file at the given index (export/download: the file is served verbatim). */
   async readFileRaw(projectId, agentId, sessionId, index) {
     const file = await this.locateByIndex(projectId, agentId, sessionId, index);
-    return fs19.readFile(file.path);
+    return fs20.readFile(file.path);
   }
   /**
    * Imports an uploaded Trace file (raw JSONL content). Validates the content itself —
@@ -9947,7 +10791,7 @@ var TraceService = class {
     const invalid = (message) => new HttpError(400, "invalid_trace", message);
     let records;
     try {
-      records = parseTraceLines2(content);
+      records = parseTraceLines2(content, { onMalformed: "throw" });
     } catch {
       throw invalid("The file is not valid Trace JSONL.");
     }
@@ -9968,12 +10812,12 @@ var TraceService = class {
     const ts = Date.parse(first.timestamp);
     const date = formatLocalDate(Number.isNaN(ts) ? /* @__PURE__ */ new Date() : new Date(ts));
     const index = 1;
-    const dir = path15.join(tracesDir3(this.root, projectId, agentId), date);
-    await fs19.mkdir(dir, { recursive: true });
-    const file = path15.join(dir, `${sessionId}_${String(index).padStart(3, "0")}.jsonl`);
+    const dir = path16.join(tracesDir3(this.root, projectId, agentId), date);
+    await fs20.mkdir(dir, { recursive: true });
+    const file = path16.join(dir, `${sessionId}_${String(index).padStart(3, "0")}.jsonl`);
     const body = content.replace(/\n+$/, "") + "\n";
     try {
-      await fs19.writeFile(file, body, { encoding: "utf8", flag: "wx" });
+      await fs20.writeFile(file, body, { encoding: "utf8", flag: "wx" });
     } catch (err) {
       if (err.code === "EEXIST") throw duplicate();
       throw err;
@@ -10289,10 +11133,10 @@ var UsageService = class {
 };
 
 // src/http/routes/preview.ts
-import { Hono as Hono22 } from "hono";
+import { Hono as Hono24 } from "hono";
 var DIRECTORY_INDEX = "index.html";
 function previewRoutes(deps2) {
-  const app2 = new Hono22();
+  const app2 = new Hono24();
   app2.get("/:token/*", async (c) => {
     const token = c.req.param("token");
     const payload = token ? deps2.previewTokens.verify(token) : null;
@@ -10349,11 +11193,18 @@ function buildAppDeps(config2, overrides = {}) {
   const usageRepo = new UsageRepo(db);
   const errorsRepo = new ErrorsRepo(db);
   const prefsRepo = new UiPrefsRepo(db);
+  const serverSettingsRepo = new ServerSettingsRepo(db);
+  const proxyEnv = () => {
+    if (!serverSettingsRepo.getProxyForAgent()) return { mode: "strip" };
+    const url = serverSettingsRepo.getProxyUrl();
+    return url === null ? null : { mode: "inject", url, noProxy: mergedNoProxy() };
+  };
   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 memoryService = new MemoryService(config2.root, agentConfigService);
   const sessionSources = new SessionSources();
   const traceIndexRepo = new TraceIndexRepo(db);
   const traceIndex = new TraceIndexService(config2.root, traceIndexRepo, sessionSources);
@@ -10383,7 +11234,7 @@ function buildAppDeps(config2, overrides = {}) {
   const manager = new SessionManager({
     sessions: sessionsRepo,
     channels,
-    loader: overrides.loader ?? createCoreSessionLoader(config2.root, sessionSources),
+    loader: overrides.loader ?? createCoreSessionLoader(config2.root, sessionSources, { proxyEnv }),
     sources: sessionSources,
     recorder,
     errors,
@@ -10407,11 +11258,15 @@ function buildAppDeps(config2, overrides = {}) {
     manager,
     traceIndex
   });
+  const onPasswordChanged = (userId) => {
+    if (userId === ADMIN_USER_ID) clearInitialAdminPassword(config2.root);
+  };
   const authService = new AuthService({
     users: usersRepo,
     authSessions: authSessionsRepo,
     provisionInitialProject: (user, isAdmin) => projectService.provisionInitialProject(user, isAdmin),
     seedAdminPassword: config2.seedAdminPassword,
+    onPasswordChanged,
     sessionTtlMs: config2.authSessionTtlMs,
     sessionRenewMs: config2.authSessionRenewMs,
     ...overrides.now ? { now: overrides.now } : {}
@@ -10421,6 +11276,7 @@ function buildAppDeps(config2, overrides = {}) {
     authSessions: authSessionsRepo,
     projects: projectsRepo,
     projectService,
+    onPasswordChanged,
     ...overrides.now ? { now: overrides.now } : {}
   });
   const sessionService = new SessionService({
@@ -10429,7 +11285,8 @@ function buildAppDeps(config2, overrides = {}) {
     manager,
     projectConfig: projectConfigService,
     sources: sessionSources,
-    traceIndex
+    traceIndex,
+    proxyEnv
   });
   const scheduler = new Scheduler({
     root: config2.root,
@@ -10450,12 +11307,14 @@ function buildAppDeps(config2, overrides = {}) {
     db,
     sessionsRepo,
     prefsRepo,
+    serverSettingsRepo,
     authService,
     adminService,
     projectService,
     projectConfigService,
     agentService,
     agentConfigService,
+    memoryService,
     sessionService,
     traceService,
     traceIndex,
@@ -10478,7 +11337,7 @@ function buildAppDeps(config2, overrides = {}) {
   };
 }
 function createApp(deps2) {
-  const app2 = new Hono23();
+  const app2 = new Hono25();
   app2.onError((err, c) => {
     const projectId = attributedProjectId(c, deps2);
     deps2.errors.record({
@@ -10531,6 +11390,7 @@ function createApp(deps2) {
   app2.route("/api/me", meRoutes(deps2));
   app2.route("/api/version", versionRoutes(deps2));
   app2.route("/api/admin/users", adminUsersRoutes(deps2));
+  app2.route("/api/admin/settings", adminSettingsRoutes(deps2));
   app2.route("/api/events", eventsRoutes(deps2));
   app2.route("/api/skills", skillLibraryRoutes());
   app2.route("/api/projects", projectsRoutes(deps2));
@@ -10541,6 +11401,7 @@ function createApp(deps2) {
   app2.route("/api/projects/:projectId/dirs", dirsRoutes(deps2));
   app2.route("/api/projects/:projectId/agents/:agentId/config", agentConfigRoutes(deps2));
   app2.route("/api/projects/:projectId/agents/:agentId/vault", vaultRoutes(deps2));
+  app2.route("/api/projects/:projectId/agents/:agentId/memory", memoryRoutes(deps2));
   app2.route("/api/projects/:projectId/agents/:agentId/schedules", scheduleRoutes(deps2));
   app2.route("/api/projects/:projectId/agents/:agentId/benchmarks", benchmarksRoutes(deps2));
   app2.route("/api/projects/:projectId/agents/:agentId/skills", agentSkillsRoutes(deps2));
@@ -10550,7 +11411,7 @@ function createApp(deps2) {
   app2.route("/api/projects/:projectId/usage", usageRoutes(deps2));
   app2.route("/api/sessions", sessionsRoutes(deps2));
   app2.route("/preview", previewRoutes(deps2));
-  if (fs20.existsSync(deps2.config.webDist)) {
+  if (fs21.existsSync(deps2.config.webDist)) {
     registerStaticRoutes(app2, deps2.config.webDist);
   }
   return app2;
@@ -10586,16 +11447,16 @@ function registerStaticRoutes(app2, webDist) {
       return c.json(errorBody("not_found", "Endpoint does not exist."), 404);
     }
     const rel = reqPath.replace(/^\/+/, "");
-    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");
+    const resolved = path17.resolve(webDist, rel === "" ? "index.html" : rel);
+    const base = path17.resolve(webDist);
+    const target = resolved === base || resolved.startsWith(base + path17.sep) ? resolved : path17.join(base, "index.html");
     let file = target;
     try {
       const stat = await fsp.stat(file);
-      if (stat.isDirectory()) file = path16.join(file, "index.html");
+      if (stat.isDirectory()) file = path17.join(file, "index.html");
       await fsp.access(file);
     } catch {
-      file = path16.join(base, "index.html");
+      file = path17.join(base, "index.html");
     }
     let content;
     try {
@@ -10603,7 +11464,7 @@ function registerStaticRoutes(app2, webDist) {
     } catch {
       return c.json(errorBody("not_found", "Resource does not exist."), 404);
     }
-    const type = CONTENT_TYPES2[path16.extname(file).toLowerCase()] ?? "application/octet-stream";
+    const type = CONTENT_TYPES2[path17.extname(file).toLowerCase()] ?? "application/octet-stream";
     return new Response(new Uint8Array(content), {
       status: 200,
       headers: { "Content-Type": type }
@@ -10613,16 +11474,16 @@ function registerStaticRoutes(app2, webDist) {
 
 // src/config.ts
 import { randomBytes as randomBytes7 } from "crypto";
-import fs21 from "fs";
-import path17 from "path";
+import fs22 from "fs";
+import path18 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 = path17.dirname(fileURLToPath(import.meta.url));
-  const bundled = path17.resolve(here, "..", "web-dist");
-  if (fs21.existsSync(bundled)) return bundled;
-  return path17.resolve(here, "..", "..", "web", "dist");
+  const here = path18.dirname(fileURLToPath(import.meta.url));
+  const bundled = path18.resolve(here, "..", "web-dist");
+  if (fs22.existsSync(bundled)) return bundled;
+  return path18.resolve(here, "..", "..", "web", "dist");
 }
 function normalizePreviewOrigin(raw) {
   if (!raw || raw.trim() === "") return null;
@@ -10652,7 +11513,7 @@ function resolveServerConfig(env = process.env) {
     root,
     host,
     port,
-    dbPath: env.PENGUIN_WEB_DB ?? path17.join(root, "web.db"),
+    dbPath: env.PENGUIN_WEB_DB ?? path18.join(root, "web.db"),
     webDist: env.PENGUIN_WEB_DIST ?? defaultWebDist(),
     previewOrigin: normalizePreviewOrigin(env.PENGUIN_PREVIEW_ORIGIN),
     // An empty/whitespace value is treated as unset (→ random seed password). Desktop
@@ -10669,6 +11530,7 @@ function resolveServerConfig(env = process.env) {
 
 // src/index.ts
 loadDotenv({ quiet: true });
+installGlobalProxyDispatcher();
 var EXIT_ALREADY_RUNNING = 3;
 var config = resolveServerConfig();
 var existingLock = await liveServerLock(config.root);
@@ -10680,23 +11542,35 @@ if (existingLock) {
   process.exit(EXIT_ALREADY_RUNNING);
 }
 var deps = buildAppDeps(config);
+applyProxySettings({
+  proxyForApp: deps.serverSettingsRepo.getProxyForApp(),
+  proxyUrl: deps.serverSettingsRepo.getProxyUrl()
+});
 var app = createApp(deps);
 var seededAdminPassword = await deps.authService.seedAdmin();
-if (seededAdminPassword !== null && config.desktopToken === null) {
-  console.log(
-    `Seeded built-in admin "admin" \u2014 initial password: ${seededAdminPassword} (change it after first sign-in)`
-  );
+if (config.desktopToken === null) {
+  if (seededAdminPassword !== null) {
+    storeInitialAdminPassword(config.root, seededAdminPassword);
+  }
+  if (deps.authService.adminPasswordIsInitial()) {
+    const initialPassword = seededAdminPassword ?? readInitialAdminPassword(config.root);
+    if (initialPassword !== null) {
+      console.log(renderInitialPasswordNotice(ADMIN_USER_ID, initialPassword));
+    }
+  } else {
+    clearInitialAdminPassword(config.root);
+  }
 }
 await deps.scheduler.start();
 deps.goalsRepo.abortOrphanedActive();
 var appHost = loopbackHostRoles(config.host)?.app ?? config.host;
 var ipv6Loopback = null;
 function writePortFile(file, port) {
-  fs22.mkdirSync(path18.dirname(file), { recursive: true });
+  fs23.mkdirSync(path19.dirname(file), { recursive: true });
   const tmp = `${file}.${process.pid}.tmp`;
-  fs22.writeFileSync(tmp, `${port}
+  fs23.writeFileSync(tmp, `${port}
 `);
-  fs22.renameSync(tmp, file);
+  fs23.renameSync(tmp, file);
 }
 var server = serve({ fetch: app.fetch, hostname: config.host, port: config.port }, (info) => {
   console.log(`penguin-server started: http://${appHost}:${info.port}`);
@@ -10723,7 +11597,7 @@ function cleanupInstanceFiles() {
   releaseServerLock(config.root);
   if (config.portFile !== null) {
     try {
-      fs22.rmSync(config.portFile, { force: true });
+      fs23.rmSync(config.portFile, { force: true });
     } catch {
     }
   }