@prismshadow/penguin-server 0.2.3 → 0.2.4

package/dist/index.js

@@ -4,6 +4,7 @@ import {
   AuthSessionsRepo,
   HttpError,
   MIN_PASSWORD_LENGTH,
+  SCRYPT_COST,
   UsersRepo,
   errorBody,
   handleError,
@@ -12,7 +13,7 @@ import {
   modelCredentialMissing,
   openDatabase,
   toUserInfo
-} from "./chunk-3QINBW3W.js";
+} from "./chunk-KQQ3HSTK.js";
 import {
   acquireServerLock,
   liveServerLock,
@@ -26,16 +27,16 @@ import {
 } from "./chunk-UUJCF46V.js";
 
 // src/index.ts
-import fs24 from "fs";
-import path19 from "path";
+import fs25 from "fs";
+import path24 from "path";
 import { config as loadDotenv } from "dotenv";
 import { serve } from "@hono/node-server";
 
 // src/app.ts
-import fs22 from "fs";
-import fsp2 from "fs/promises";
-import path17 from "path";
-import { Hono as Hono26 } from "hono";
+import fs23 from "fs";
+import fsp3 from "fs/promises";
+import path22 from "path";
+import { Hono as Hono28 } from "hono";
 import { bodyLimit } from "hono/body-limit";
 
 // src/net/proxy.ts
@@ -987,6 +988,13 @@ var UiPrefsRepo = class {
 };
 
 // src/db/repos/usage.ts
+var BUCKET_EXPRS = {
+  minute: `strftime('%Y-%m-%dT%H:%M', ts, 'localtime')`,
+  hour: `strftime('%Y-%m-%dT%H:00', ts, 'localtime')`,
+  day: "date",
+  week: `date(date, '-6 days', 'weekday 1')`,
+  month: "substr(date, 1, 7)"
+};
 var GROUP_COLUMNS = {
   date: "date",
   agent: "agent_id",
@@ -1048,6 +1056,14 @@ var UsageRepo = class {
       conds.push("date <= :to");
       params.to = f.to;
     }
+    if (f.fromTs !== void 0) {
+      conds.push("ts >= :fromTs");
+      params.fromTs = f.fromTs;
+    }
+    if (f.toTs !== void 0) {
+      conds.push("ts <= :toTs");
+      params.toTs = f.toTs;
+    }
     if (f.agentId !== void 0) {
       conds.push("agent_id = :agentId");
       params.agentId = f.agentId;
@@ -1084,34 +1100,45 @@ var UsageRepo = class {
     return rows.map((r) => ({ key: r.key, ...toSums(r) }));
   }
   /**
-   * Raw success-rate counts per Model (paired reference) (completed / non-aborted requests):
-   * powers the cost center's "Model Success Rate" chart. The denominator excludes aborted
-   * (user-initiated interruption); failure breakdowns (failed / timeout / malformed) are
-   * also returned for hover display. Unknown statuses aren't broken out but still count
-   * toward the denominator (conservative: anything non-completed counts as a failure).
+   * Time-series sums (bucket key x paired reference breakdown) with per-bucket
+   * success-rate counts riding along: powers the cost center's time-series charts
+   * (requests / success rate / Token / cost) at the requested precision. The
+   * denominator excludes aborted.
    */
-  statusByModel(projectId, f = {}) {
+  seriesByModel(projectId, granularity, f = {}) {
+    const expr = BUCKET_EXPRS[granularity];
+    const { where, params } = this.conds(projectId, f);
+    const rows = this.db.prepare(
+      `SELECT ${expr} AS key, provider, model_id, ${SUM_COLUMNS},
+                COALESCE(SUM(CASE WHEN status = 'completed' THEN 1 ELSE 0 END), 0) AS completed,
+                COALESCE(SUM(CASE WHEN status <> 'aborted' THEN 1 ELSE 0 END), 0) AS denominator
+         FROM usage_records WHERE ${where}
+         GROUP BY key, provider, model_id`
+    ).all(params);
+    return rows.map((r) => ({
+      key: r.key,
+      ...toSums(r),
+      completed: r.completed,
+      denominator: r.denominator
+    }));
+  }
+  /** Per-Agent counts per time bucket (the by-Agent requests chart's series; the denominator excludes aborted). */
+  agentSeries(projectId, granularity, f = {}) {
+    const expr = BUCKET_EXPRS[granularity];
     const { where, params } = this.conds(projectId, f);
-    const count = (status) => `COALESCE(SUM(CASE WHEN status = '${status}' THEN 1 ELSE 0 END), 0) AS ${status}`;
     const rows = this.db.prepare(
-      `SELECT provider, model_id,
-                ${count("completed")},
-                ${count("aborted")},
-                ${count("failed")},
-                ${count("timeout")},
-                ${count("malformed")},
-                COALESCE(SUM(CASE WHEN status <> 'aborted' THEN 1 ELSE 0 END), 0) AS total
-         FROM usage_records WHERE ${where} GROUP BY provider, model_id`
+      `SELECT ${expr} AS key, agent_id, COUNT(*) AS requests,
+                COALESCE(SUM(CASE WHEN status = 'completed' THEN 1 ELSE 0 END), 0) AS completed,
+                COALESCE(SUM(CASE WHEN status <> 'aborted' THEN 1 ELSE 0 END), 0) AS denominator
+         FROM usage_records WHERE ${where}
+         GROUP BY key, agent_id`
     ).all(params);
     return rows.map((r) => ({
-      provider: r.provider,
-      modelId: r.model_id,
+      key: r.key,
+      agentId: r.agent_id,
+      requests: r.requests,
       completed: r.completed,
-      total: r.total,
-      aborted: r.aborted,
-      failed: r.failed,
-      timeout: r.timeout,
-      malformed: r.malformed
+      denominator: r.denominator
     }));
   }
   /** Distinct agent_id values seen for this Project (for filter dropdowns). */
@@ -1169,6 +1196,13 @@ var jsonOnlyWrites = async (c, next) => {
   await next();
 };
 
+// src/platform/terminal/identity.ts
+var IDENTITY_RESOURCE_ID = "runtime:identity";
+function identityFrom(resources) {
+  const resolver = resources.claim(IDENTITY_RESOURCE_ID);
+  return resolver ?? (async () => null);
+}
+
 // src/http/routes/admin.ts
 import { Hono as Hono2 } from "hono";
 
@@ -1202,6 +1236,40 @@ function desktopRoutes(deps2) {
   });
   return app2;
 }
+function desktopUpdateRoutes(deps2) {
+  const app2 = new Hono();
+  const requireShellSession = (c) => {
+    const desktop = deps2.desktop;
+    if (!desktop) throw new HttpError(404, "not_found", "Desktop mode is not enabled.");
+    if (c.var.sessionVia !== "desktop") {
+      throw new HttpError(
+        403,
+        "desktop_shell_only",
+        "Client updates are managed from the desktop app's own window."
+      );
+    }
+    return desktop;
+  };
+  app2.get("/", (c) => {
+    const desktop = requireShellSession(c);
+    return c.json({ status: desktop.getUpdateStatus() });
+  });
+  app2.post("/check", (c) => {
+    const desktop = requireShellSession(c);
+    if (!desktop.requestUpdateCommand("check")) {
+      throw new HttpError(503, "shell_unreachable", "The desktop shell is not listening.");
+    }
+    return c.body(null, 202);
+  });
+  app2.post("/install", (c) => {
+    const desktop = requireShellSession(c);
+    if (!desktop.requestUpdateCommand("install")) {
+      throw new HttpError(503, "shell_unreachable", "The desktop shell is not listening.");
+    }
+    return c.body(null, 202);
+  });
+  return app2;
+}
 
 // src/http/validate.ts
 import { isValidId } from "@prismshadow/penguin-core";
@@ -1573,6 +1641,48 @@ function resolvePreviewTarget(requestUrl, hostHeader, configuredOrigin, serverBi
   return { origin: `${protocol}//${counterpart}${suffix}`, host: counterpart };
 }
 
+// src/services/draft-shortcuts.ts
+var DRAFT_SHORTCUT_MAX_COUNT = 3;
+var DRAFT_SHORTCUT_TITLE_MAX = 40;
+var DRAFT_SHORTCUT_PROMPT_MAX = 4e3;
+var DRAFT_SHORTCUT_ID_MAX = 64;
+function invalid(message) {
+  return new HttpError(400, "invalid_draft_shortcuts", message);
+}
+function shortcutField(entry, key, index, maxLen) {
+  const value = entry[key];
+  if (typeof value !== "string") {
+    throw invalid(`draftShortcuts[${index}].${key} must be a string.`);
+  }
+  const trimmed = value.trim();
+  if (trimmed === "") throw invalid(`draftShortcuts[${index}].${key} must not be empty.`);
+  if (trimmed.length > maxLen) {
+    throw invalid(`draftShortcuts[${index}].${key} must be at most ${maxLen} characters.`);
+  }
+  return trimmed;
+}
+function validateDraftShortcuts(value) {
+  if (!Array.isArray(value)) throw invalid("draftShortcuts must be an array.");
+  if (value.length > DRAFT_SHORTCUT_MAX_COUNT) {
+    throw invalid(`draftShortcuts must hold at most ${DRAFT_SHORTCUT_MAX_COUNT} shortcuts.`);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return value.map((entry, index) => {
+    if (entry === null || typeof entry !== "object" || Array.isArray(entry)) {
+      throw invalid(`draftShortcuts[${index}] must be an object.`);
+    }
+    const raw = entry;
+    const id = shortcutField(raw, "id", index, DRAFT_SHORTCUT_ID_MAX);
+    if (seen.has(id)) throw invalid(`draftShortcuts[${index}].id duplicates an earlier id.`);
+    seen.add(id);
+    return {
+      id,
+      title: shortcutField(raw, "title", index, DRAFT_SHORTCUT_TITLE_MAX),
+      prompt: shortcutField(raw, "prompt", index, DRAFT_SHORTCUT_PROMPT_MAX)
+    };
+  });
+}
+
 // src/http/routes/me.ts
 function meRoutes(deps2) {
   const app2 = new Hono5();
@@ -1623,6 +1733,9 @@ function meRoutes(deps2) {
   });
   app2.put("/prefs", async (c) => {
     const body = await readJson(c);
+    if (body.draftShortcuts !== void 0) {
+      body.draftShortcuts = validateDraftShortcuts(body.draftShortcuts);
+    }
     const raw = deps2.prefsRepo.get(c.var.user.userId);
     let current2 = {};
     if (raw !== null) {
@@ -1815,8 +1928,8 @@ function isHttpUrl(value) {
     return false;
   }
 }
-function probeUrl(baseUrl, path20) {
-  return baseUrl.trim().replace(/\/+$/, "") + path20;
+function probeUrl(baseUrl, path25) {
+  return baseUrl.trim().replace(/\/+$/, "") + path25;
 }
 function isApiErrorShape(body) {
   const err = body.error;
@@ -2133,6 +2246,21 @@ function modelsRoutes(deps2) {
     }
     return c.json(await deps2.projectConfigService.detectProtocol(projectId, req));
   });
+  app2.post("/list", async (c) => {
+    const projectId = requireValidId(c, "projectId");
+    deps2.projectService.requireProjectOwner(c.var.user.userId, projectId);
+    const body = await readJson(c);
+    const req = {
+      baseUrl: requireString(body, "baseUrl", { minLen: 1, maxLen: 2e3 }),
+      clientType: requireString(body, "clientType", { minLen: 1, maxLen: 64 })
+    };
+    if (!isHttpUrl(req.baseUrl)) throw badRequest("baseUrl must be an absolute http(s) URL.");
+    if (body.apiKey !== void 0) {
+      if (typeof body.apiKey !== "string") throw badRequest("apiKey must be a string.");
+      if (body.apiKey) req.apiKey = body.apiKey;
+    }
+    return c.json(await deps2.projectConfigService.listEndpointModels(req));
+  });
   app2.post("/detect-vision", async (c) => {
     const projectId = requireValidId(c, "projectId");
     deps2.projectService.requireProjectOwner(c.var.user.userId, projectId);
@@ -3479,15 +3607,17 @@ function sessionsRoutes(deps2) {
     const aborted = deps2.manager.abortTask(row.sessionId);
     return c.body(null, aborted ? 202 : 204);
   });
-  app2.get("/:sessionId/processes", (c) => {
+  app2.get("/:sessionId/processes", async (c) => {
     const row = resolveSession(c);
+    await deps2.manager.probeProcessServices(row.sessionId);
     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
+      running: p.running,
+      ...p.serviceUrl !== void 0 ? { serviceUrl: p.serviceUrl } : {}
     }));
     return c.json({ processes });
   });
@@ -3676,8 +3806,98 @@ function chatDefaultsRoutes(deps2) {
   return app2;
 }
 
-// src/http/routes/vault.ts
+// src/http/routes/command-policy.ts
 import { Hono as Hono12 } from "hono";
+var MAX_RULES = 64;
+var MAX_RULE_NAME_LEN = 64;
+var MAX_RULE_PATTERN_LEN = 512;
+var MAX_RULE_DESCRIPTION_LEN = 300;
+function validateRules(value) {
+  if (!Array.isArray(value)) {
+    throw new HttpError(400, "invalid_rules", "rules must be an array.");
+  }
+  if (value.length > MAX_RULES) {
+    throw new HttpError(400, "invalid_rules", `rules exceeds ${MAX_RULES} entries.`);
+  }
+  const rules = [];
+  for (const entry of value) {
+    if (entry === null || typeof entry !== "object" || Array.isArray(entry)) {
+      throw new HttpError(400, "invalid_rules", "Each rule must be an object.");
+    }
+    const { name, pattern, description, enabled } = entry;
+    if (typeof name !== "string" || name.trim() === "" || name.length > MAX_RULE_NAME_LEN) {
+      throw new HttpError(
+        400,
+        "invalid_rules",
+        `Each rule needs a non-empty name of at most ${MAX_RULE_NAME_LEN} characters.`
+      );
+    }
+    if (typeof pattern !== "string" || pattern === "" || pattern.length > MAX_RULE_PATTERN_LEN) {
+      throw new HttpError(
+        400,
+        "invalid_rules",
+        `Each rule needs a non-empty pattern of at most ${MAX_RULE_PATTERN_LEN} characters.`
+      );
+    }
+    try {
+      new RegExp(pattern);
+    } catch {
+      throw new HttpError(
+        400,
+        "invalid_rule_pattern",
+        `Rule "${name.trim()}" has an invalid regular expression: ${pattern}`
+      );
+    }
+    if (description !== void 0 && typeof description !== "string") {
+      throw new HttpError(400, "invalid_rules", "A rule description must be a string.");
+    }
+    const desc = typeof description === "string" ? description.trim() : "";
+    if (desc.length > MAX_RULE_DESCRIPTION_LEN) {
+      throw new HttpError(
+        400,
+        "invalid_rules",
+        `A rule description is at most ${MAX_RULE_DESCRIPTION_LEN} characters.`
+      );
+    }
+    if (enabled !== void 0 && typeof enabled !== "boolean") {
+      throw new HttpError(400, "invalid_rules", "A rule's enabled must be a boolean.");
+    }
+    rules.push({
+      name: name.trim(),
+      pattern,
+      ...desc !== "" ? { description: desc } : {},
+      ...enabled !== void 0 ? { enabled } : {}
+    });
+  }
+  return rules;
+}
+function commandPolicyRoutes(deps2) {
+  const app2 = new Hono12();
+  app2.get("/", async (c) => {
+    const projectId = requireValidId(c, "projectId");
+    deps2.projectService.requireProjectAccess(c.var.user.userId, projectId);
+    return c.json(await deps2.projectConfigService.getCommandPolicy(projectId));
+  });
+  app2.put("/", async (c) => {
+    const projectId = requireValidId(c, "projectId");
+    deps2.projectService.requireProjectOwner(c.var.user.userId, projectId);
+    const body = await readJson(c);
+    if (body.enabled !== void 0 && typeof body.enabled !== "boolean") {
+      throw new HttpError(400, "invalid_enabled", "enabled must be a boolean.");
+    }
+    const rules = validateRules(body.rules);
+    return c.json(
+      await deps2.projectConfigService.setCommandPolicy(projectId, {
+        ...body.enabled !== void 0 ? { enabled: body.enabled } : {},
+        rules
+      })
+    );
+  });
+  return app2;
+}
+
+// src/http/routes/vault.ts
+import { Hono as Hono13 } from "hono";
 function parseVaultUpdate(body) {
   if (!Array.isArray(body.entries)) throw badRequest("entries must be an array.");
   const entries = body.entries.map((item, i) => {
@@ -3699,7 +3919,7 @@ function parseVaultUpdate(body) {
   return { entries };
 }
 function vaultRoutes(deps2) {
-  const app2 = new Hono12();
+  const app2 = new Hono13();
   app2.get("/", async (c) => {
     const projectId = requireValidId(c, "projectId");
     const agentId = requireValidId(c, "agentId");
@@ -3730,9 +3950,15 @@ function vaultRoutes(deps2) {
 }
 
 // src/http/routes/memory.ts
-import { Hono as Hono13 } from "hono";
+import { Hono as Hono14 } from "hono";
+var IMPORT_MODES = ["skip", "overwrite", "replace"];
+function exportStamp(exportedAt) {
+  const d = new Date(exportedAt);
+  const p = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}`;
+}
 function memoryRoutes(deps2) {
-  const app2 = new Hono13();
+  const app2 = new Hono14();
   const scope = (c) => {
     const projectId = requireValidId(c, "projectId");
     const agentId = requireValidId(c, "agentId");
@@ -3758,6 +3984,31 @@ function memoryRoutes(deps2) {
     const name = pathParam(c, "fileName");
     return c.json(await deps2.memoryService.readFile(projectId, agentId, key, name));
   });
+  app2.get("/scopes/:scopeKey/export", async (c) => {
+    const { projectId, agentId } = scope(c);
+    const key = pathParam(c, "scopeKey");
+    const doc = await deps2.memoryService.exportScope(projectId, agentId, key);
+    return new Response(JSON.stringify(doc, null, 2), {
+      headers: {
+        "Content-Type": "application/json; charset=utf-8",
+        "Content-Disposition": `attachment; filename="${agentId}-${key}-memory-${exportStamp(doc.exportedAt)}.json"`
+      }
+    });
+  });
+  app2.post("/scopes/:scopeKey/import", async (c) => {
+    const projectId = requireValidId(c, "projectId");
+    const agentId = requireValidId(c, "agentId");
+    deps2.projectService.requireProjectOwner(c.var.user.userId, projectId);
+    const key = pathParam(c, "scopeKey");
+    const body = await readJson(c);
+    return c.json(
+      await deps2.memoryService.importScope(projectId, agentId, key, {
+        mode: optionalEnum(body, "mode", IMPORT_MODES) ?? "skip",
+        confirm: optionalBoolean(body, "confirm") ?? false,
+        payload: body.payload
+      })
+    );
+  });
   app2.delete("/scopes/:scopeKey/files/:fileName", async (c) => {
     const { projectId, agentId } = scope(c);
     const key = pathParam(c, "scopeKey");
@@ -3770,7 +4021,7 @@ function memoryRoutes(deps2) {
 
 // src/http/routes/schedules.ts
 import { createHash } from "crypto";
-import { Hono as Hono14 } from "hono";
+import { Hono as Hono15 } from "hono";
 import { isValidId as isValidId3 } from "@prismshadow/penguin-core";
 
 // src/runtime/schedule-file.ts
@@ -3977,7 +4228,7 @@ var ScheduleFileCache = class {
   async scan(projectId, agentId, force) {
     const key = this.keyOf(projectId, agentId);
     const dir = scheduleDir(this.root, projectId, agentId);
-    const cached = this.seen.get(key);
+    const cached2 = this.seen.get(key);
     this.counters.gateStats += 1;
     const dirMtime = await statMtime(dir);
     if (dirMtime === null) {
@@ -3986,9 +4237,9 @@ var ScheduleFileCache = class {
     }
     const next = { mtimeMs: cacheable(dirMtime), files: /* @__PURE__ */ new Map() };
     let names;
-    if (!force && cached !== void 0 && cached.mtimeMs !== null && cached.mtimeMs === dirMtime) {
-      next.mtimeMs = cached.mtimeMs;
-      names = [...cached.files.keys()];
+    if (!force && cached2 !== void 0 && cached2.mtimeMs !== null && cached2.mtimeMs === dirMtime) {
+      next.mtimeMs = cached2.mtimeMs;
+      names = [...cached2.files.keys()];
     } else {
       this.counters.dirScans += 1;
       let listing;
@@ -4002,7 +4253,7 @@ var ScheduleFileCache = class {
     }
     const entries = [];
     for (const name of names) {
-      const file = await this.revalidate(dir, name, cached?.files.get(name));
+      const file = await this.revalidate(dir, name, cached2?.files.get(name));
       if (file === null) continue;
       next.files.set(name, file);
       entries.push(file.entry);
@@ -4011,7 +4262,7 @@ var ScheduleFileCache = class {
     return entries;
   }
   /** Reuses the cached parse while the file's stat still matches; re-reads otherwise. */
-  async revalidate(dir, name, cached) {
+  async revalidate(dir, name, cached2) {
     const file = path4.join(dir, `${name}.toml`);
     let stat;
     try {
@@ -4019,7 +4270,7 @@ var ScheduleFileCache = class {
     } catch {
       return null;
     }
-    if (cached && cached.mtimeMs === stat.mtimeMs && cached.sizeBytes === stat.size) return cached;
+    if (cached2 && cached2.mtimeMs === stat.mtimeMs && cached2.sizeBytes === stat.size) return cached2;
     this.counters.fileReads += 1;
     let raw;
     try {
@@ -4152,17 +4403,17 @@ function requireScheduleName(raw) {
   return raw;
 }
 function scheduleRoutes(deps2) {
-  const app2 = new Hono14();
+  const app2 = new Hono15();
   app2.get("/", async (c) => {
     const projectId = requireValidId(c, "projectId");
     const agentId = requireValidId(c, "agentId");
     deps2.projectService.requireProjectAccess(c.var.user.userId, projectId);
     await deps2.agentConfigService.requireExists(projectId, agentId);
-    const { entries, invalid } = await deps2.scheduler.listAgent(projectId, agentId);
+    const { entries, invalid: invalid2 } = await deps2.scheduler.listAgent(projectId, agentId);
     const nowMs = Date.now();
     const res = {
       schedules: entries.map((e) => toItem(e.def, e.state, e.queued, nowMs)),
-      invalidFiles: invalid
+      invalidFiles: invalid2
     };
     return c.json(res);
   });
@@ -4242,16 +4493,16 @@ async function upsert(deps2, userId, projectId, agentId, name, body) {
   await deps2.scheduler.reconcileAgent(projectId, agentId);
 }
 async function readItem(deps2, projectId, agentId, name) {
-  const { entries, invalid } = await deps2.scheduler.listAgent(projectId, agentId);
+  const { entries, invalid: invalid2 } = await deps2.scheduler.listAgent(projectId, agentId);
   const entry = entries.find((e) => e.def.name === name);
   if (entry) return toItem(entry.def, entry.state, entry.queued, Date.now());
-  const bad = invalid.find((i) => i.name === name);
+  const bad = invalid2.find((i) => i.name === name);
   if (bad) throw badRequest(`Invalid schedule file: ${bad.error}`);
   throw new HttpError(404, "schedule_not_found", `Schedule does not exist: ${name}`);
 }
 
 // src/http/routes/benchmarks.ts
-import { Hono as Hono15 } from "hono";
+import { Hono as Hono16 } from "hono";
 var TEXT_PREVIEW_BYTES = 256 * 1024;
 function listCaseFiles(deps2, material) {
   return async (c) => {
@@ -4304,7 +4555,7 @@ function readCaseFile(deps2, material) {
   };
 }
 function benchmarksRoutes(deps2) {
-  const app2 = new Hono15();
+  const app2 = new Hono16();
   app2.get("/", async (c) => {
     const projectId = requireValidId(c, "projectId");
     const agentId = requireValidId(c, "agentId");
@@ -4331,7 +4582,7 @@ function benchmarksRoutes(deps2) {
 import fs7 from "fs/promises";
 import path5 from "path";
 import { unzipSync, strFromU8, zipSync } from "fflate";
-import { Hono as Hono16 } from "hono";
+import { Hono as Hono17 } from "hono";
 import {
   installSkill,
   listInstalledSkills,
@@ -4478,12 +4729,12 @@ function parseInstallNames(body) {
   });
 }
 function skillLibraryRoutes() {
-  const app2 = new Hono16();
+  const app2 = new Hono17();
   app2.get("/", (c) => c.json(libraryResponse()));
   return app2;
 }
 function agentSkillsRoutes(deps2) {
-  const app2 = new Hono16();
+  const app2 = new Hono17();
   const listResponse = async (projectId, agentId) => ({
     skills: (await listInstalledSkills(deps2.config.root, projectId, agentId)).map(toMetadataItem)
   });
@@ -4601,10 +4852,10 @@ function agentSkillsRoutes(deps2) {
 
 // src/http/routes/agent-transfer.ts
 import fs8 from "fs/promises";
-import { Hono as Hono17 } from "hono";
+import { Hono as Hono18 } from "hono";
 var MAX_ARCHIVE_BYTES2 = 14 * 1024 * 1024;
 function agentTransferRoutes(deps2) {
-  const app2 = new Hono17();
+  const app2 = new Hono18();
   app2.get("/export", async (c) => {
     const projectId = requireValidId(c, "projectId");
     const agentId = requireValidId(c, "agentId");
@@ -4643,7 +4894,7 @@ function agentTransferRoutes(deps2) {
 }
 
 // src/http/routes/agents.ts
-import { Hono as Hono18 } from "hono";
+import { Hono as Hono19 } from "hono";
 
 // src/http/settle.ts
 async function settleWithin(promises, ms) {
@@ -4657,7 +4908,7 @@ async function settleWithin(promises, ms) {
 // src/http/routes/agents.ts
 var ACTIVITY_DAYS = 30;
 function agentsRoutes(deps2) {
-  const app2 = new Hono18();
+  const app2 = new Hono19();
   app2.get("/", async (c) => {
     const projectId = requireValidId(c, "projectId");
     deps2.projectService.requireProjectAccess(c.var.user.userId, projectId);
@@ -4724,9 +4975,9 @@ function agentsRoutes(deps2) {
 import fs9 from "fs/promises";
 import os from "os";
 import path6 from "path";
-import { Hono as Hono19 } from "hono";
+import { Hono as Hono20 } from "hono";
 function dirsRoutes(deps2) {
-  const app2 = new Hono19();
+  const app2 = new Hono20();
   app2.get("/", async (c) => {
     const projectId = requireValidId(c, "projectId");
     deps2.projectService.requireProjectAccess(c.var.user.userId, projectId);
@@ -4770,11 +5021,11 @@ function dirsRoutes(deps2) {
 import { mkdtemp, rm } from "fs/promises";
 import { tmpdir } from "os";
 import { join } from "path";
-import { Hono as Hono20 } from "hono";
+import { Hono as Hono21 } from "hono";
 import { McpToolProvider, resolveMCPServer } from "@prismshadow/penguin-core";
 var MCP_TEST_TIMEOUT_CAP_MS = 3e4;
 function agentConfigRoutes(deps2) {
-  const app2 = new Hono20();
+  const app2 = new Hono21();
   app2.get("/", async (c) => {
     const projectId = requireValidId(c, "projectId");
     const agentId = requireValidId(c, "agentId");
@@ -4877,7 +5128,7 @@ function agentConfigRoutes(deps2) {
 }
 
 // src/http/routes/agent-traces.ts
-import { Hono as Hono21 } from "hono";
+import { Hono as Hono22 } from "hono";
 var MAX_TRACE_BYTES = 14 * 1024 * 1024;
 var SESSION_CATEGORIES2 = [
   "active",
@@ -4886,7 +5137,7 @@ var SESSION_CATEGORIES2 = [
   "archived"
 ];
 function agentTracesRoutes(deps2) {
-  const app2 = new Hono21();
+  const app2 = new Hono22();
   app2.get("/", async (c) => {
     const projectId = requireValidId(c, "projectId");
     const agentId = requireValidId(c, "agentId");
@@ -4964,10 +5215,17 @@ function agentTracesRoutes(deps2) {
 }
 
 // src/http/routes/usage.ts
-import { Hono as Hono22 } from "hono";
+import { Hono as Hono23 } from "hono";
 var GROUP_BYS = ["date", "agent", "model", "session"];
+var GRANULARITIES = ["minute", "hour", "day", "week", "month"];
+function optionalTsParam(value, label) {
+  if (value === void 0 || value === "") return void 0;
+  const ms = Date.parse(value);
+  if (Number.isNaN(ms)) throw badRequest(`${label} must be an ISO-8601 timestamp.`);
+  return new Date(ms).toISOString();
+}
 function usageRoutes(deps2) {
-  const app2 = new Hono22();
+  const app2 = new Hono23();
   app2.get("/", async (c) => {
     const projectId = requireValidId(c, "projectId");
     deps2.projectService.requireProjectAccess(c.var.user.userId, projectId);
@@ -4975,14 +5233,30 @@ function usageRoutes(deps2) {
     if (!GROUP_BYS.includes(groupByRaw)) {
       throw badRequest(`groupBy must be one of ${GROUP_BYS.join(" / ")}.`);
     }
+    const granularityRaw = c.req.query("granularity") ?? "day";
+    if (!GRANULARITIES.includes(granularityRaw)) {
+      throw badRequest(`granularity must be one of ${GRANULARITIES.join(" / ")}.`);
+    }
+    const granularity = granularityRaw;
     const from = optionalDateParam(c.req.query("from"), "from");
     const to = optionalDateParam(c.req.query("to"), "to");
+    const fromTs = optionalTsParam(c.req.query("fromTs"), "fromTs");
+    const toTs = optionalTsParam(c.req.query("toTs"), "toTs");
+    if (fromTs === void 0 !== (toTs === void 0)) {
+      throw badRequest("fromTs and toTs must be given together.");
+    }
+    if (fromTs !== void 0 && toTs !== void 0 && fromTs > toTs) {
+      throw badRequest("fromTs must not be after toTs.");
+    }
     const agentId = c.req.query("agentId");
     const provider = c.req.query("provider");
     const modelId = c.req.query("modelId");
     return c.json(
       await deps2.usageService.query(projectId, {
         groupBy: groupByRaw,
+        granularity,
+        ...fromTs !== void 0 ? { fromTs } : {},
+        ...toTs !== void 0 ? { toTs } : {},
         // Unattributed errors (login failures, process crashes, etc. with no Project
         // context) are visible only to admins: requireProjectAccess only guarantees
         // "is a member of this Project" — a regular member seeing another tenant's errors
@@ -5022,7 +5296,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 Hono23 } from "hono";
+import { Hono as Hono24 } from "hono";
 var OUTPUT_CAP = 64 * 1024;
 var UPDATE_TIMEOUT_MS = 10 * 60 * 1e3;
 var REFUSAL_MARKERS = [
@@ -5088,7 +5362,7 @@ function runSelfUpdate(cliEntry) {
   });
 }
 function versionRoutes(deps2) {
-  const app2 = new Hono23();
+  const app2 = new Hono24();
   let inflightRun = null;
   app2.get("/", (c) => {
     return c.json({ version: VERSION, buildDate: BUILD_DATE });
@@ -5268,6 +5542,77 @@ function localDateMinusDays(date, days) {
   d.setDate(d.getDate() - days);
   return formatLocalDate(d);
 }
+function parseLocalDate(date) {
+  const [y, m, d] = date.split("-").map(Number);
+  return new Date(y, m - 1, d);
+}
+function formatLocalHourKey(date) {
+  const hour = date.getHours().toString().padStart(2, "0");
+  return `${formatLocalDate(date)}T${hour}:00`;
+}
+function formatLocalMinuteKey(date) {
+  const hour = date.getHours().toString().padStart(2, "0");
+  const minute = date.getMinutes().toString().padStart(2, "0");
+  return `${formatLocalDate(date)}T${hour}:${minute}`;
+}
+function enumerateTsBuckets(fromTs, toTs, granularity, cap = Infinity) {
+  const keys = [];
+  if (fromTs.getTime() > toTs.getTime()) return keys;
+  const start = new Date(fromTs);
+  start.setSeconds(0, 0);
+  if (granularity === "hour") start.setMinutes(0);
+  const stepMs = granularity === "hour" ? 36e5 : 6e4;
+  const fmt = granularity === "hour" ? formatLocalHourKey : formatLocalMinuteKey;
+  const seen = /* @__PURE__ */ new Set();
+  for (let t = start.getTime(); t <= toTs.getTime() && keys.length <= cap; t += stepMs) {
+    const key = fmt(new Date(t));
+    if (seen.has(key)) continue;
+    seen.add(key);
+    keys.push(key);
+  }
+  return keys;
+}
+function localWeekStart(date) {
+  const d = parseLocalDate(date);
+  d.setDate(d.getDate() - (d.getDay() + 6) % 7);
+  return formatLocalDate(d);
+}
+function localMonthKey(date) {
+  return date.slice(0, 7);
+}
+function enumerateBuckets(from, to, granularity, cap = Infinity) {
+  const keys = [];
+  if (from > to) return keys;
+  const full = () => keys.length > cap;
+  if (granularity === "hour") {
+    const end = parseLocalDate(to);
+    end.setHours(23);
+    const seen = /* @__PURE__ */ new Set();
+    for (let t = parseLocalDate(from).getTime(); t <= end.getTime() && !full(); t += 36e5) {
+      const key = formatLocalHourKey(new Date(t));
+      if (seen.has(key)) continue;
+      seen.add(key);
+      keys.push(key);
+    }
+    return keys;
+  }
+  if (granularity === "month") {
+    const end = localMonthKey(to);
+    const d2 = parseLocalDate(`${localMonthKey(from)}-01`);
+    for (; ; ) {
+      const key = localMonthKey(formatLocalDate(d2));
+      if (key > end || full()) return keys;
+      keys.push(key);
+      d2.setMonth(d2.getMonth() + 1);
+    }
+  }
+  const stepDays = granularity === "week" ? 7 : 1;
+  const d = parseLocalDate(granularity === "week" ? localWeekStart(from) : from);
+  for (; formatLocalDate(d) <= to && !full(); d.setDate(d.getDate() + stepDays)) {
+    keys.push(formatLocalDate(d));
+  }
+  return keys;
+}
 
 // src/runtime/error-recorder.ts
 var MESSAGE_MAX = 500;
@@ -5906,8 +6251,6 @@ function toUnrecoverableError(err) {
 }
 var ENTRY_IDLE_MS = 30 * 60 * 1e3;
 var ENTRY_SWEEP_INTERVAL_MS = 60 * 1e3;
-var TITLE_EXCERPT_LIMIT = 4e3;
-var EARLY_TITLE_BODY_CHARS = 1e3;
 function agentKey(projectId, agentId) {
   return `${projectId}\0${agentId}`;
 }
@@ -5953,12 +6296,6 @@ function isPlainText(role) {
     return msg.type === "model_msg" && payload.type === "text" && payload.role === role && (!msg.origin || msg.origin.length === 0);
   };
 }
-function nestedAssistantText(msg) {
-  const p = msg.payload;
-  if (msg.type !== "model_msg" || p.type !== "text" || p.role !== "assistant") return null;
-  if (!msg.origin || msg.origin.length === 0 || typeof p.text !== "string") return null;
-  return { sessionId: msg.origin[msg.origin.length - 1], text: p.text };
-}
 var SessionManager = class {
   constructor(deps2) {
     this.deps = deps2;
@@ -6058,6 +6395,38 @@ var SessionManager = class {
       pendingSteering: [],
       lastActivityMs: Date.now()
     });
+    this.registerNoticeListener(row.sessionId, session);
+  }
+  /**
+   * Subscribes the background hooks on a runtime Session entering the active table — every
+   * insertion path must call it (ensureEntry's loads, adopt's fresh creations):
+   * - the idle-arrival signal for completion notices (mid-run arrivals are delivered inside
+   *   the run by core; this signal is the only trigger left when the session sits idle);
+   * - live-forwarded background-subagent messages, published to the session channel (the
+   *   same feed SSE relays) and recorded for usage — a background child streams to the
+   *   frontend in real time past the launching turn's end, until its terminal state.
+   */
+  registerNoticeListener(sessionId, session) {
+    session.onBackgroundNotice?.(() => void this.startBackgroundNoticeTask(sessionId));
+    session.onBackgroundMessage?.((msg) => this.forwardBackgroundMessage(sessionId, msg));
+  }
+  /** Publishes one live background-subagent message and records its usage (fire-and-forget; the child's own Trace is the durable record). */
+  forwardBackgroundMessage(sessionId, msg) {
+    const entry = this.entries.get(sessionId);
+    if (!entry) return;
+    entry.lastActivityMs = Date.now();
+    this.deps.channels.get(entry.sessionId).publish(msg);
+    const ctx = {
+      projectId: entry.projectId,
+      agentId: entry.agentId,
+      sessionId: entry.sessionId,
+      provider: entry.provider,
+      modelId: entry.modelId
+    };
+    void this.deps.recorder.record(ctx, msg).catch((err) => {
+      this.log(`[usage] Insert failed: ${err instanceof Error ? err.message : String(err)}`);
+      this.deps.errors?.record({ source: "usage", err, ctx, code: "usage_insert_failed" });
+    });
   }
   /**
    * After an Agent's vault is updated: bump the Agent's config generation so every
@@ -6498,6 +6867,15 @@ var SessionManager = class {
   listProcesses(sessionId) {
     return this.entries.get(sessionId)?.session.listBackgroundCommands?.() ?? [];
   }
+  /**
+   * Refreshes the listen-port probes behind the process list's `serviceUrl` (core
+   * `Session.probeBackgroundCommandServices`): called by the processes route before
+   * listing, so the first fetch already carries probed URLs. Bounded by core's own probe
+   * timeout and TTL; a session that isn't loaded has no processes to probe.
+   */
+  async probeProcessServices(sessionId) {
+    await this.entries.get(sessionId)?.session.probeBackgroundCommandServices?.();
+  }
   /** 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);
@@ -6642,6 +7020,8 @@ var SessionManager = class {
       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 (entry.session.hasRunningBackgroundSubagents?.()) continue;
+      if (entry.session.hasPendingBackgroundNotices?.()) continue;
       if (now - entry.lastActivityMs <= idleMs) continue;
       this.entries.delete(key);
     }
@@ -6740,17 +7120,45 @@ var SessionManager = class {
       lastActivityMs: Date.now()
     };
     this.entries.set(currentId, entry);
+    this.registerNoticeListener(currentId, session);
     return entry;
   }
+  /**
+   * Auto-start of queued background completion notices: called when core signals an
+   * idle-session arrival, and from drive's finally for notices that raced a run's exit.
+   * Revalidates under the session lock; only an idle entry launches, and only when the
+   * queue is non-empty — a busy entry skips, because the running/queued task's engine
+   * drains the same queue at its own boundaries (each notice is delivered exactly once).
+   */
+  async startBackgroundNoticeTask(sessionId) {
+    try {
+      await this.withLock(sessionId, async () => {
+        if (this.closed || this.deletingSessions.has(sessionId)) return;
+        const row = this.deps.sessions.findById(sessionId);
+        if (row && this.deletingAgents.has(agentKey(row.projectId, row.agentId))) return;
+        const entry = this.entries.get(sessionId);
+        if (!entry) {
+          this.log(`[background] notice for ${sessionId} dropped: runtime entry not loaded`);
+          return;
+        }
+        if (entry.status !== "idle" || entry.followUps.length > 0) return;
+        const input = entry.session.takeBackgroundNotices?.() ?? [];
+        if (input.length === 0) return;
+        this.launchTask(entry, input);
+      });
+    } catch (err) {
+      this.log(
+        `[background] notice task start failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
   /**
    * Drive the output stream in the background: publish each message + persist usage +
    * persist LLM/tool errors; on completion (including errors) resets to idle and pushes
    * the status. `titleSource` is passed only for Task runs (compaction doesn't generate
-   * a title): it collects model text for automatic title generation.
+   * a title): its user text drives automatic title generation at run start.
    */
   async drive(entry, gen, titleSource) {
-    let earlyTitleFired = false;
-    let mainBodyChars = 0;
     const ctx = {
       projectId: entry.projectId,
       agentId: entry.agentId,
@@ -6758,6 +7166,12 @@ var SessionManager = class {
       provider: entry.provider,
       modelId: entry.modelId
     };
+    if (titleSource?.userExcerpt.trim()) {
+      this.deps.titles?.maybeGenerate(ctx, entry.session, {
+        fallbackText: titleSource.userExcerpt,
+        material: { userText: titleSource.userExcerpt, assistantText: "" }
+      });
+    }
     this.touchRow(ctx, (repo, at) => repo.markDriven(ctx.sessionId, at));
     const watcher = this.deps.errors ? new StreamErrorWatcher(this.deps.errors, {
       projectId: entry.projectId,
@@ -6788,6 +7202,18 @@ var SessionManager = class {
                 child.prompt = subagentPrompts.get(pendingId) ?? "";
                 subagentPrompts.delete(pendingId);
               }
+              if (child.prompt.trim()) {
+                this.deps.titles?.maybeGenerate(
+                  { ...ctx, agentId: child.agentId, sessionId: child.sessionId },
+                  entry.session,
+                  {
+                    fallbackText: child.prompt,
+                    material: { userText: child.prompt, assistantText: "" },
+                    notifyOn: entry.sessionId
+                    // Notify the frontend via the parent Session's SSE channel
+                  }
+                );
+              }
             }
           } catch (err) {
             this.log(
@@ -6800,24 +7226,6 @@ var SessionManager = class {
               code: "subagent_register_failed"
             });
           }
-        } else {
-          const nested = nestedAssistantText(msg);
-          const child = nested ? children.get(nested.sessionId) : void 0;
-          if (nested && child && child.assistantExcerpt.length < TITLE_EXCERPT_LIMIT) {
-            child.assistantExcerpt += (child.assistantExcerpt ? "\n" : "") + nested.text;
-          }
-        }
-        if (!earlyTitleFired && titleSource?.userExcerpt.trim()) {
-          const p = msg.payload;
-          if ((!msg.origin || msg.origin.length === 0) && msg.type === "model_msg" && p.type === "text" && p.role === "assistant" && p.text) {
-            mainBodyChars += p.text.length;
-            if (mainBodyChars >= EARLY_TITLE_BODY_CHARS) {
-              earlyTitleFired = true;
-              this.deps.titles?.maybeGenerate(ctx, entry.session, {
-                fallbackText: titleSource.userExcerpt
-              });
-            }
-          }
         }
         if (!msg.origin || msg.origin.length === 0) {
           const bt = msg.payload.type;
@@ -6855,41 +7263,19 @@ var SessionManager = class {
       entry.lastActivityMs = Date.now();
       this.touchRow(ctx, (repo, at) => repo.touchLastActive(ctx.sessionId, at));
       this.publishState(entry, "idle");
-      if (titleSource && titleSource.userExcerpt.trim()) {
-        this.deps.titles?.maybeGenerate(ctx, entry.session, {
-          fallbackText: titleSource.userExcerpt
-        });
-      }
       if (entry.followUps.length > 0) void this.startQueuedFollowUp(entry.sessionId);
-      for (const child of children.values()) {
-        if (!child.prompt.trim()) continue;
-        this.deps.titles?.maybeGenerate(
-          // Bookkeeping: Session/Agent record the subagent (the title belongs to it),
-          // but the model reference still uses ctx's **parent-Session** pair
-          // (provider, modelId) — this one-shot request really does run on the parent
-          // Session's bare LLM (a subagent may switch models via run_subagent's
-          // model_id).
-          { ...ctx, agentId: child.agentId, sessionId: child.sessionId },
-          entry.session,
-          {
-            fallbackText: child.prompt,
-            material: { userText: child.prompt, assistantText: child.assistantExcerpt },
-            notifyOn: entry.sessionId
-            // Notify the frontend via the parent Session's SSE channel
-          }
-        );
-      }
+      else void this.startBackgroundNoticeTask(entry.sessionId);
     }
   }
   /**
    * Register a subagent: persisted only when the origin message is session_meta
    * (agentId is derived from the agent_state path: `<…>/<agentId>/agent_state`).
-   * **The title is left blank** — it's generated at the end of this run by the model
-   * from the subagent's own conversation (see drive's finally), falling back to the
-   * first line of the run_subagent prompt if generation fails. Idempotent (children
-   * dedup + insertOrIgnore); a subagent has its own Trace, so it's visible in both the
-   * list and the trace view. On successful registration, the entry is put into
-   * `children` and returned; a duplicate session_meta returns null.
+   * **The title is left blank here** — the registration site in drive generates it
+   * right away from the spawning prompt (fallback first words + LLM replacement), so
+   * it never waits for the subagent's own output. Idempotent (children dedup +
+   * insertOrIgnore); a subagent has its own Trace, so it's visible in both the list
+   * and the trace view. On successful registration, the entry is put into `children`
+   * and returned; a duplicate session_meta returns null.
    */
   registerChildSession(entry, msg, children) {
     if (!isSessionMeta2(msg)) return null;
@@ -6929,9 +7315,7 @@ var SessionManager = class {
     const child = {
       sessionId: childSid,
       agentId,
-      modelId: p.model_id,
-      prompt: "",
-      assistantExcerpt: ""
+      prompt: ""
     };
     children.set(childSid, child);
     return child;
@@ -7070,10 +7454,10 @@ var Scheduler = class {
     const owner = project?.ownerUserId ?? null;
     const files = await this.files.list(projectId, agentId);
     const entries = [];
-    const invalid = [];
+    const invalid2 = [];
     for (const file of files) {
       if (!file.parsed.ok) {
-        invalid.push({ name: file.name, error: file.parsed.error });
+        invalid2.push({ name: file.name, error: file.parsed.error });
         continue;
       }
       const refError = await validateScheduleModelRef(
@@ -7082,7 +7466,7 @@ var Scheduler = class {
         file.parsed.def
       );
       if (refError !== null) {
-        invalid.push({ name: file.name, error: refError });
+        invalid2.push({ name: file.name, error: refError });
         continue;
       }
       const state = this.registerEntry(projectId, agentId, owner, file.parsed.def, file.raw);
@@ -7097,7 +7481,7 @@ var Scheduler = class {
       agentId,
       files.map((f) => f.name)
     );
-    return { entries, invalid };
+    return { entries, invalid: invalid2 };
   }
   /** For routes: state cleanup after a task is deleted (the unlink moved the dir mtime, but invalidate for immediate effect anyway). */
   dropEntry(projectId, agentId, name) {
@@ -7121,13 +7505,13 @@ var Scheduler = class {
    * removed Agents also drop their schedule-file cache entries here.
    */
   async listAgentIds(projectId) {
-    const cached = this.agentDirs.get(projectId);
+    const cached2 = this.agentDirs.get(projectId);
     const mtimeMs = await statMtime(agentsDir(this.deps.root, projectId));
     if (mtimeMs === null) {
       this.agentDirs.delete(projectId);
       return [];
     }
-    if (cached && cached.mtimeMs === mtimeMs) return cached.ids;
+    if (cached2 && cached2.mtimeMs === mtimeMs) return cached2.ids;
     let ids;
     try {
       const items = await fs11.readdir(agentsDir(this.deps.root, projectId), {
@@ -7138,7 +7522,7 @@ var Scheduler = class {
       this.agentDirs.delete(projectId);
       return [];
     }
-    for (const gone of cached?.ids.filter((id) => !ids.includes(id)) ?? []) {
+    for (const gone of cached2?.ids.filter((id) => !ids.includes(id)) ?? []) {
       this.files.invalidate(projectId, gone);
     }
     this.agentDirs.set(projectId, { mtimeMs: cacheable(mtimeMs), ids });
@@ -7269,7 +7653,8 @@ var Scheduler = class {
     const firedAt = new Date(this.now()).toISOString();
     try {
       await this.deps.runner.startTask(sessionId, [
-        userText2(scheduledMessage(def.name, firedAt, def.prompt))
+        // sender "server": in the Trace this user turn was injected by the server's scheduler, not typed by a human.
+        userText2(scheduledMessage(def.name, firedAt, def.prompt), "server")
       ]);
     } catch (err) {
       this.deps.errors.record({
@@ -7323,6 +7708,8 @@ var Scheduler = class {
 // src/runtime/title-generator.ts
 import {
   emptyTokenCounts,
+  matchAttachedFileLine,
+  matchAttachedImageLine,
   sanitizeTitle,
   stripConversationMarkers,
   tokenUsage
@@ -7334,11 +7721,30 @@ var TitleGenerator = class {
   }
   deps;
   inflight = /* @__PURE__ */ new Set();
+  /**
+   * sessionId → the fallback title this generator wrote and the LLM may still replace.
+   * An entry is dropped once the LLM result lands or a differing stored title (a manual
+   * rename, or a title from before a restart) is observed — from then on the title is
+   * treated as final. In-memory on purpose: the sessions table stores no auto/manual
+   * marker, and after a restart an existing title is simply left alone.
+   */
+  pendingFallbacks = /* @__PURE__ */ new Map();
   log;
-  /** Generate a title in the background (fire-and-forget) when conditions are met: the row exists, title is still NULL, and no generation is already in flight. */
+  /**
+   * Runs the title policy for one run start (fire-and-forget): persists the user-input
+   * fallback if the row has no title yet, then generates the LLM replacement in the
+   * background. No-ops when the stored title is anything other than NULL or the fallback
+   * this generator wrote (manual renames and pre-existing titles are final), or when a
+   * generation is already in flight.
+   */
   maybeGenerate(ctx, session, req) {
-    const row = this.deps.sessions.findById(ctx.sessionId);
-    if (!row || row.title !== null) return;
+    try {
+      if (!this.prepare(ctx, req)) return;
+    } catch (err) {
+      this.log(`[title] Fallback failed: ${err instanceof Error ? err.message : String(err)}`);
+      this.deps.errors?.record({ source: "title", err, ctx, code: "title_fallback_failed" });
+      return;
+    }
     if (this.inflight.has(ctx.sessionId)) return;
     this.inflight.add(ctx.sessionId);
     void this.generate(ctx, session, req).catch((err) => {
@@ -7348,6 +7754,24 @@ var TitleGenerator = class {
       this.inflight.delete(ctx.sessionId);
     });
   }
+  /** Synchronous half of the policy: decides whether the LLM should run, writing the immediate fallback title on the way. */
+  prepare(ctx, req) {
+    const row = this.deps.sessions.findById(ctx.sessionId);
+    if (!row) return false;
+    if (row.title !== null) {
+      if (row.title !== this.pendingFallbacks.get(ctx.sessionId)) {
+        this.pendingFallbacks.delete(ctx.sessionId);
+        return false;
+      }
+      return true;
+    }
+    const fallback = fallbackTitle(req.fallbackText);
+    if (fallback !== null) {
+      this.pendingFallbacks.set(ctx.sessionId, fallback);
+      this.persist(ctx, fallback, req.notifyOn);
+    }
+    return true;
+  }
   async generate(ctx, session, req) {
     let title = null;
     try {
@@ -7374,21 +7798,60 @@ var TitleGenerator = class {
       this.log(`[title] Model request failed: ${err instanceof Error ? err.message : String(err)}`);
       this.deps.errors?.record({ source: "title", err, ctx, code: "title_llm_failed" });
     }
-    const finalTitle = title ?? fallbackTitle(req.fallbackText);
-    if (finalTitle === null) return;
+    if (title === null) return;
     const latest = this.deps.sessions.findById(ctx.sessionId);
-    if (!latest || latest.title !== null) return;
-    this.deps.sessions.updateTitle(ctx.sessionId, finalTitle);
-    this.deps.channels.get(req.notifyOn ?? ctx.sessionId).publish(
-      { type: "session_title", sessionId: ctx.sessionId, title: finalTitle },
-      "server_event"
-    );
+    if (!latest) return;
+    if (latest.title !== null && latest.title !== this.pendingFallbacks.get(ctx.sessionId)) {
+      this.pendingFallbacks.delete(ctx.sessionId);
+      return;
+    }
+    this.pendingFallbacks.delete(ctx.sessionId);
+    this.persist(ctx, title, req.notifyOn);
+  }
+  /**
+   * Writes sessions.title and pushes the `session_title` event — to the given Session
+   * channel (the session's own unless overridden) for the tab watching the conversation,
+   * and to the Project's user-level channels for every session list. The latter is the
+   * delivery that survives the start-of-run timing: a first Task's title fires before the
+   * new Session's own channel has any subscriber.
+   */
+  persist(ctx, title, notifyOn) {
+    this.deps.sessions.updateTitle(ctx.sessionId, title);
+    const event = { type: "session_title", sessionId: ctx.sessionId, title };
+    this.deps.channels.get(notifyOn ?? ctx.sessionId).publish(event, "server_event");
+    this.deps.notifyProjectUsers?.(ctx.projectId, event);
   }
 };
+var FALLBACK_MAX_CHARS = 30;
 function fallbackTitle(text) {
-  const firstLine = stripConversationMarkers(text).split("\n").find((l) => l.trim().length > 0);
+  const firstLine = stripConversationMarkers(text).split("\n").find((l) => l.trim().length > 0 && !isAttachmentLine(l.trim()));
   if (!firstLine) return null;
-  return sanitizeTitle(firstLine) ?? firstLine.trim().slice(0, 30);
+  const collapsed = firstLine.replace(/\s+/g, " ").trim();
+  const lead = collapsed.replace(
+    /^["'“”‘’「」『』《》〈〉【】()（）。.．!！?？;；,，、:：\s]+/,
+    ""
+  );
+  const cut = truncateAtWord(lead || collapsed);
+  return sanitizeTitle(cut) ?? cut;
+}
+function isAttachmentLine(line) {
+  return matchAttachedImageLine(line) !== null || matchAttachedFileLine(line) !== null;
+}
+function truncateAtWord(text) {
+  if (text.length <= FALLBACK_MAX_CHARS) return text;
+  const end = splitsSurrogatePair(text, FALLBACK_MAX_CHARS) ? FALLBACK_MAX_CHARS - 1 : FALLBACK_MAX_CHARS;
+  const cut = text.slice(0, end);
+  const wordChar = /[A-Za-z0-9'’_-]/;
+  if (wordChar.test(text[end]) && wordChar.test(cut[cut.length - 1])) {
+    const lastSpace = cut.lastIndexOf(" ");
+    if (lastSpace > 0) return cut.slice(0, lastSpace).trimEnd();
+  }
+  return cut.trimEnd();
+}
+function splitsSurrogatePair(text, i) {
+  const high = text.charCodeAt(i - 1);
+  const low = text.charCodeAt(i);
+  return high >= 55296 && high <= 56319 && low >= 56320 && low <= 57343;
 }
 
 // src/runtime/usage-recorder.ts
@@ -7473,9 +7936,11 @@ var AdminService = class {
   constructor(deps2) {
     this.deps = deps2;
     this.now = deps2.now ?? (() => /* @__PURE__ */ new Date());
+    this.hashCost = deps2.passwordHashCost ?? SCRYPT_COST;
   }
   deps;
   now;
+  hashCost;
   listUsers() {
     return this.deps.users.list().map(toUserInfo);
   }
@@ -7495,7 +7960,7 @@ var AdminService = class {
     }
     const user = {
       userId,
-      passwordHash: await hashPassword(password),
+      passwordHash: await hashPassword(password, this.hashCost),
       isAdmin: false,
       passwordIsInitial: true,
       createdAt: this.now().toISOString()
@@ -7517,7 +7982,7 @@ var AdminService = class {
     if (password.length < MIN_PASSWORD_LENGTH) {
       throw new HttpError(400, "invalid_password", "Password must be at least 8 characters.");
     }
-    this.deps.users.updatePassword(userId, await hashPassword(password), true);
+    this.deps.users.updatePassword(userId, await hashPassword(password, this.hashCost), true);
     this.deps.authSessions.deleteByUser(userId);
     this.deps.onPasswordChanged?.(userId);
   }
@@ -7569,6 +8034,27 @@ var DesktopService = class {
     this.shutdownHandler();
     return true;
   }
+  // --- client-update relay ---------------------------------------------------
+  updateStatus = null;
+  updateCommandSender = null;
+  /** Latest shell snapshot; null until the shell's first push lands. */
+  getUpdateStatus() {
+    return this.updateStatus;
+  }
+  /** index.ts stores each shell push here (already validated at the message port). */
+  setUpdateStatus(status) {
+    this.updateStatus = status;
+  }
+  /** index.ts registers the message-port sender; absent outside a shell-forked process. */
+  onUpdateCommand(sender) {
+    this.updateCommandSender = sender;
+  }
+  /** Invoked by the update routes; false when no shell port is wired (tests, plain runs). */
+  requestUpdateCommand(action) {
+    if (!this.updateCommandSender) return false;
+    this.updateCommandSender(action);
+    return true;
+  }
 };
 
 // src/services/agent-config-service.ts
@@ -7610,8 +8096,12 @@ import { parse as parseToml2 } from "smol-toml";
 import {
   CHAT_APPROVAL_MODES,
   DEFAULT_CHAT_THINKING_LEVELS as DEFAULT_CHAT_THINKING_LEVELS2,
+  DEFAULT_COMMAND_POLICY_RULES,
+  effectiveCommandPolicyRules,
+  parseCommandPolicy,
   GenerativeModel,
   canonicalClientType,
+  listEndpointModels as coreListEndpointModels,
   catalogEntryFor,
   defaultProjectConfig,
   imageUrlMessage as imageUrlMessage2,
@@ -7621,6 +8111,7 @@ import {
   resolveModelEnv as resolveModelEnv2,
   userText as userText3
 } from "@prismshadow/penguin-core";
+import { providerInfo } from "@prismshadow/penguin-core/model-catalog";
 
 // src/services/vision-detect.ts
 var VISION_PROBE_IMAGE = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII=";
@@ -7667,6 +8158,17 @@ function maskApiKey(key) {
   if (key.length <= 12) return "***";
   return `${key.slice(0, 4)}\u2026${key.slice(-4)}`;
 }
+function envFallbackFirstParty(entry) {
+  const group = providerInfo(entry.provider);
+  if (group === void 0 || group.id === "custom" || group.gatewayBaseUrl !== void 0) {
+    return false;
+  }
+  const cat = catalogEntryFor(entry.provider, entry.modelId);
+  if (cat !== void 0) {
+    return canonicalClientType(entry.clientType) === canonicalClientType(cat.clientType) && entry.baseUrl === cat.baseUrl;
+  }
+  return entry.clientType === void 0 && entry.baseUrl === void 0;
+}
 function asTable(v) {
   return v !== null && typeof v === "object" && !Array.isArray(v) ? v : {};
 }
@@ -7679,6 +8181,14 @@ function optNum(v) {
 function optStr(v) {
   return typeof v === "string" && v !== "" ? v : void 0;
 }
+function toCommandPolicyRuleDtos(rules) {
+  return rules.map((r) => ({
+    name: r.name,
+    pattern: r.pattern,
+    ...r.description !== void 0 ? { description: r.description } : {},
+    enabled: r.enabled !== false
+  }));
+}
 function optRef(v) {
   const t = asTable(v);
   const provider = optStr(t.provider);
@@ -7695,6 +8205,7 @@ function showRef(provider, modelId) {
   return `(provider=${provider}, model_id=${modelId})`;
 }
 var PROBE_PROMPT = 'ping - reply with the single word "pong" and nothing else. Do not think or explain.\n<think></think>';
+var LIST_MODELS_TIMEOUT_MS = 2e4;
 var SPEED_PROBE_PROMPT = "Count from 1 to 50 as a comma-separated list, and nothing else. Do not think or explain.\n<think></think>";
 var ProjectConfigService = class {
   constructor(root) {
@@ -7745,8 +8256,8 @@ var ProjectConfigService = class {
       this.cache.delete(projectId);
       return null;
     }
-    const cached = this.cache.get(projectId);
-    if (cached && cached.mtimeMs === mtimeMs) return cached.table;
+    const cached2 = this.cache.get(projectId);
+    if (cached2 && cached2.mtimeMs === mtimeMs) return cached2.table;
     let raw;
     try {
       raw = await fs12.readFile(file, "utf8");
@@ -7795,6 +8306,9 @@ var ProjectConfigService = class {
     await this.writeRaw(projectId, {
       name,
       ...preset.default_model !== void 0 ? { default_model: preset.default_model } : {},
+      // The factory command-policy rules are seeded exactly like the model presets:
+      // copied in at creation, owned by the project from then on.
+      ...preset.command_policy !== void 0 ? { command_policy: preset.command_policy } : {},
       models: preset.models
     });
   }
@@ -7902,6 +8416,44 @@ var ProjectConfigService = class {
     await this.writeRaw(projectId, next);
     return this.getChatDefaults(projectId);
   }
+  /**
+   * Sandbox command policy (`[command_policy]`): read leniently, mirroring core's
+   * loadProjectConfig tolerance — a non-boolean `enabled` reads as true (the default), a
+   * rule missing name or pattern is dropped, and an absent (or non-array) `rules` value
+   * serves the factory set: a project from before the block was seeded behaves as the
+   * defaults until its first saved edit materializes them. The factory set also rides
+   * along as `defaultRules` for the settings UI's "restore defaults".
+   */
+  async getCommandPolicy(projectId) {
+    const raw = await this.readRaw(projectId);
+    const policy = parseCommandPolicy(raw.command_policy);
+    return {
+      enabled: policy?.enabled !== false,
+      rules: toCommandPolicyRuleDtos(effectiveCommandPolicyRules(policy)),
+      defaultRules: toCommandPolicyRuleDtos(DEFAULT_COMMAND_POLICY_RULES)
+    };
+  }
+  /**
+   * Replaces the `[command_policy]` block (declarative PUT, validated at the route). A PUT
+   * always materializes the full rule list into the file — model-presets style: once
+   * written, later factory changes never rewrite it — storing per field only what departs
+   * from the defaults (`enabled = false`, a rule's `enabled = false`, a non-empty
+   * description). Read-modify-write like setChatDefaults, preserving every other key.
+   * Returns the block as re-read.
+   */
+  async setCommandPolicy(projectId, req) {
+    const raw = await this.readRaw(projectId);
+    const block = {};
+    if (req.enabled === false) block.enabled = false;
+    block.rules = req.rules.map((r) => ({
+      name: r.name,
+      pattern: r.pattern,
+      ...r.description !== void 0 && r.description !== "" ? { description: r.description } : {},
+      ...r.enabled === false ? { enabled: false } : {}
+    }));
+    await this.writeRaw(projectId, { ...raw, command_policy: block });
+    return this.getCommandPolicy(projectId);
+  }
   /** Pricing lookup for usage-recorder: the current pricing for this paired reference (undefined if none -> cost is NULL). */
   async getPricing(projectId, provider, modelId) {
     const raw = await this.readRaw(projectId);
@@ -7919,15 +8471,15 @@ var ProjectConfigService = class {
    * Model connectivity test: the model reference `(provider, modelId)` is submitted
    * as a pair in the request body; sends one minimal request using that model's
    * config (optionally overridden with an unsaved apiKey / baseUrl) — no tools, no
-   * system prompt, thinking disabled, a tiny output cap, 20s timeout — just to see
-   * whether the endpoint answers. The model id sent to AgentHub is `modelId`
-   * itself (the upstream id verbatim; client_type inference follows it).
+   * system prompt, thinking at the lowest level, a tiny output cap, 20s timeout —
+   * just to see whether the endpoint answers. The model id sent to AgentHub is
+   * `modelId` itself (the upstream id verbatim; client_type inference follows it).
    *
-   * A reasoning-heavy model may ignore the disabled thinking level and burn the
-   * whole tiny output cap on thinking (finish_reason=length with no text — AgentHub
-   * raises EmptyResponseError, collapsed to a malformed outcome): the endpoint
-   * demonstrably streamed model output, which is everything a connectivity test
-   * proves, so that case counts as ok too (see probeVerdict).
+   * A reasoning-heavy model can spend the whole tiny output cap on thinking
+   * (finish_reason=length with no text — AgentHub raises EmptyResponseError,
+   * collapsed to a malformed outcome): the endpoint demonstrably streamed model
+   * output, which is everything a connectivity test proves, so that case counts as
+   * ok too (see probeVerdict).
    *
    * Never throws: the LLM layer collapses auth/parameter/network errors into an
    * `LLMOutcome`, which is translated here into ok / message. Consumes very few
@@ -7960,7 +8512,9 @@ var ProjectConfigService = class {
         ...baseUrl ? { baseUrl } : {},
         ...clientType ? { clientType } : {},
         tools: [],
-        thinkingLevel: "none",
+        // The lowest real level, not "none": several reasoning endpoints reject a request
+        // that disables thinking outright, and a probe must not fail on the knob it sends.
+        thinkingLevel: "low",
         maxTokens: VISION_PROBE_MAX_TOKENS,
         requestTimeoutMs: VISION_PROBE_TIMEOUT_MS
       });
@@ -8005,7 +8559,9 @@ var ProjectConfigService = class {
         ...clientType ? { clientType } : {},
         ...fastMode ? { fastMode: true } : {},
         tools: [],
-        thinkingLevel: "none",
+        // The lowest real level, not "none": several reasoning endpoints reject a request
+        // that disables thinking outright, and a probe must not fail on the knob it sends.
+        thinkingLevel: "low",
         // Speed mode pairs a raised cap with a prompt that keeps generating (see
         // SPEED_PROBE_PROMPT), so the stream lasts long enough for TTFT/TPS to describe
         // decoding rather than one round trip; the plain connectivity test keeps the
@@ -8073,6 +8629,45 @@ var ProjectConfigService = class {
     }
     return detectModelProtocol({ baseUrl: req.baseUrl, ...apiKey ? { apiKey } : {} });
   }
+  /**
+   * Endpoint model listing for the add-group import (see EndpointModelListRequest). All
+   * parameters come from the request — a group being created has no stored entry to fall
+   * back to; an omitted key follows the same environment chain as the connectivity test
+   * (the wrapped SDK reads the protocol's own variable). Never throws: SDK construction
+   * and request failures collapse into `{ ok:false, message }`, an AgentHub
+   * UnsupportedOperationError additionally sets `unsupported` so the dialog can point at
+   * the manual path, and a listing that outlives LIST_MODELS_TIMEOUT_MS is reported as
+   * timed out. Nothing cancels the request behind it: the race only stops waiting, and a
+   * later rejection is already handled by the race itself. The listing is returned
+   * verbatim; dedup against the config is the caller's policy, exactly like the probe
+   * routes never write anything either.
+   */
+  async listEndpointModels(req, listImpl = coreListEndpointModels, timeoutMs = LIST_MODELS_TIMEOUT_MS) {
+    const clientType = canonicalClientType(req.clientType) ?? req.clientType;
+    let timer;
+    try {
+      const listing = listImpl({
+        clientType,
+        baseUrl: req.baseUrl,
+        ...req.apiKey ? { apiKey: req.apiKey } : {}
+      });
+      const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error("model listing timed out")), timeoutMs);
+        timer.unref?.();
+      });
+      const models = await Promise.race([listing, timeout]);
+      return { ok: true, models };
+    } catch (err) {
+      const unsupported = err instanceof Error && err.name === "UnsupportedOperationError";
+      return {
+        ok: false,
+        ...unsupported ? { unsupported: true } : {},
+        message: (err instanceof Error ? err.message : String(err)).slice(0, 300)
+      };
+    } finally {
+      if (timer !== void 0) clearTimeout(timer);
+    }
+  }
   /**
    * GET models view: masks credential (inline fields), flags the default Model;
    * the group is the entry's `provider` field, looked up in the built-in catalog by
@@ -8105,6 +8700,8 @@ var ProjectConfigService = class {
       const apiKey = optStr(m.api_key);
       const credBaseUrl = optStr(m.base_url);
       const createdAt = optStr(m.created_at);
+      const envValue = envKey !== void 0 && envFallbackFirstParty({ provider, modelId, clientType, baseUrl: credBaseUrl }) ? process.env[envKey] ?? "" : "";
+      const envKeyMasked = envValue !== "" ? maskApiKey(envValue) : void 0;
       const info = {
         provider,
         modelId,
@@ -8116,6 +8713,7 @@ var ProjectConfigService = class {
         ...maxTokens !== void 0 ? { maxTokens } : {},
         ...fastMode !== void 0 ? { fastMode } : {},
         ...envKey ? { envKey } : {},
+        ...envKeyMasked !== void 0 ? { envKeyMasked } : {},
         ...pricingDto ? { pricing: pricingDto } : {},
         ...apiKey !== void 0 || credBaseUrl !== void 0 ? {
           credential: {
@@ -8461,8 +9059,8 @@ var AgentConfigService = class {
     const cfg = config2;
     const yamlPath = systemConfigPath(this.root, projectId, agentId);
     const doc = parseDocument(await fs13.readFile(yamlPath, "utf8"));
-    const setIfProvided = (path20, value) => {
-      if (value !== void 0) doc.setIn(path20, value);
+    const setIfProvided = (path25, value) => {
+      if (value !== void 0) doc.setIn(path25, value);
     };
     setIfProvided(["name"], optionalString(cfg, "name", { maxLen: 100, label: "name" }));
     setIfProvided(
@@ -8659,6 +9257,7 @@ function validateMcpServers(value) {
 }
 
 // src/services/memory-service.ts
+import { randomBytes as randomBytes4 } from "crypto";
 import fs14 from "fs/promises";
 import path10 from "path";
 import {
@@ -8672,9 +9271,76 @@ import {
   readWorkspaceMarker
 } from "@prismshadow/penguin-core";
 var SCOPE_KEY_PATTERN = /^[A-Za-z0-9_][A-Za-z0-9._-]*$/;
+var SCOPE_FORMAT = "penguin-memory-scope";
+var SCOPE_FORMAT_VERSION = 1;
+var MAX_IMPORT_FILES = 500;
+var MAX_IMPORT_FILE_BYTES = 512 * 1024;
+var MAX_IMPORT_TOTAL_BYTES = 8 * 1024 * 1024;
+var MAX_IMPORT_NAME_BYTES = 255;
+function indexLinkPattern(fileName) {
+  const escaped = fileName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`\\]\\(\\s*<?(?:\\./)?${escaped}>?\\s*(?:"[^"]*"\\s*)?\\)`);
+}
 function isTopicFileName(name) {
   return name.length > 0 && !name.startsWith(".") && !/[/\\]/.test(name) && name.toLowerCase().endsWith(".md") && name.toLowerCase() !== MEMORY_INDEX_FILENAME.toLowerCase();
 }
+function parseTransferDocument(payload) {
+  if (payload === null || typeof payload !== "object" || Array.isArray(payload)) {
+    throw badRequest("payload must be a Memory scope export object.");
+  }
+  const doc = payload;
+  if (doc.format !== SCOPE_FORMAT) {
+    throw badRequest(`payload.format must be "${SCOPE_FORMAT}".`);
+  }
+  if (doc.version !== SCOPE_FORMAT_VERSION) {
+    throw badRequest(`payload.version must be ${SCOPE_FORMAT_VERSION}.`);
+  }
+  if (!Array.isArray(doc.files)) throw badRequest("payload.files must be an array.");
+  if (doc.files.length > MAX_IMPORT_FILES) {
+    throw badRequest(`payload.files must hold at most ${MAX_IMPORT_FILES} entries.`);
+  }
+  let total = 0;
+  const measure = (text, label) => {
+    if (text.includes("\0")) throw badRequest(`${label} must be text.`);
+    const bytes = Buffer.byteLength(text, "utf8");
+    if (bytes > MAX_IMPORT_FILE_BYTES) {
+      throw badRequest(`${label} exceeds the ${MAX_IMPORT_FILE_BYTES / 1024}KB limit.`);
+    }
+    total += bytes;
+    if (total > MAX_IMPORT_TOTAL_BYTES) {
+      throw badRequest(
+        `payload exceeds the ${MAX_IMPORT_TOTAL_BYTES / (1024 * 1024)}MB total limit.`
+      );
+    }
+  };
+  let index = null;
+  if (doc.index !== null && doc.index !== void 0) {
+    if (typeof doc.index !== "string") throw badRequest("payload.index must be a string or null.");
+    measure(doc.index, "payload.index");
+    index = doc.index;
+  }
+  const files = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of doc.files) {
+    if (entry === null || typeof entry !== "object" || Array.isArray(entry)) {
+      throw badRequest("Each payload.files entry must be an object.");
+    }
+    const { name, content } = entry;
+    if (typeof name !== "string") throw badRequest("Each payload.files entry needs a name.");
+    if (typeof content !== "string") {
+      throw badRequest(`Content of ${name} must be a string.`);
+    }
+    if (name.includes("\0")) throw badRequest("A file name must be text.");
+    if (Buffer.byteLength(name, "utf8") > MAX_IMPORT_NAME_BYTES) {
+      throw badRequest(`A file name must be at most ${MAX_IMPORT_NAME_BYTES} bytes.`);
+    }
+    if (seen.has(name)) throw badRequest(`payload.files names ${name} twice.`);
+    seen.add(name);
+    measure(content, `Content of ${name}`);
+    files.push({ name, content });
+  }
+  return { index, files };
+}
 var MemoryService = class {
   constructor(root, agentConfigService) {
     this.root = root;
@@ -8748,9 +9414,22 @@ var MemoryService = class {
       kind,
       ...workspacePath !== void 0 ? { workspacePath } : {},
       fileCount: files.length,
+      hasIndex: await this.hasIndexFile(dir),
       ...latest > 0 ? { updatedAt: new Date(latest).toISOString() } : {}
     };
   }
+  /**
+   * Whether the scope holds its own `MEMORY.md`. lstat, not stat: a symlink planted at that name
+   * is not an index — treating it as one would carry a read or a write outside the Memory
+   * directory, and the atomic write below replaces such a link instead of following it.
+   */
+  async hasIndexFile(dir) {
+    try {
+      return (await fs14.lstat(path10.join(dir, MEMORY_INDEX_FILENAME))).isFile();
+    } catch {
+      return false;
+    }
+  }
   /** 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 {
@@ -8785,6 +9464,146 @@ var MemoryService = class {
       throw new HttpError(404, "memory_file_not_found", `Memory file not found: ${fileName}`);
     }
   }
+  /**
+   * The whole scope as one transfer document: every topic file plus the scope's own `MEMORY.md`.
+   *
+   * JSON rather than an archive, because the payload is entirely UTF-8 Markdown and the import
+   * side of it is an untrusted write into the Agent's Memory directory: a JSON document carries
+   * no paths, no permissions and no compression, so its entries can go through the same per-file
+   * name check every other write here uses, with nothing to unpack first.
+   *
+   * Unreadable entries are left out rather than failing the export, as elsewhere in this service.
+   * The size bounds below apply to import only — an export reports what the directory actually
+   * holds, and a scope grown past them is exactly the thing its owner needs to see.
+   */
+  async exportScope(projectId, agentId, scopeKey) {
+    const dir = await this.requireScopeDir(projectId, agentId, scopeKey);
+    const files = [];
+    for (const name of await this.topicFileNames(dir)) {
+      const content = await this.readTextFile(path10.join(dir, name));
+      if (content !== null) files.push({ name, content });
+    }
+    const kind = scopeKey === USER_SCOPE_KEY ? "user" : "workspace";
+    const workspacePath = kind === "workspace" ? await readWorkspaceMarker(dir) : void 0;
+    return {
+      format: SCOPE_FORMAT,
+      version: SCOPE_FORMAT_VERSION,
+      scopeKey,
+      kind,
+      ...workspacePath !== void 0 ? { workspacePath } : {},
+      exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      index: await this.hasIndexFile(dir) ? await this.readTextFile(path10.join(dir, MEMORY_INDEX_FILENAME)) : null,
+      files
+    };
+  }
+  /**
+   * Writes a transfer document into one scope.
+   *
+   * The default mode keeps every file already on disk and writes only names the scope does not
+   * have, so an import can never cost the user a memory they did not agree to lose. `overwrite`
+   * replaces a same-named file's content and `replace` additionally deletes what the document
+   * does not carry; both are refused with 409 unless `confirm` is set — but only when they would
+   * actually destroy something, since a confirmation that names nothing is just a click.
+   *
+   * The index follows the files. A scope with no index takes the document's; `replace` takes it
+   * too (the whole scope is being replaced); a merge keeps the index that is there and appends
+   * the document's lines for the files this import added, because only the indexes enter the
+   * model's context and an unindexed memory is one the Agent never reads.
+   */
+  async importScope(projectId, agentId, scopeKey, request) {
+    const dir = await this.requireScopeDir(projectId, agentId, scopeKey);
+    const { index, files } = parseTransferDocument(request.payload);
+    const planned = files.map((f) => ({ ...f, target: this.resolveFile(dir, f.name) }));
+    const present = new Set(await this.topicFileNames(dir));
+    const carried = new Set(files.map((f) => f.name));
+    const collides = files.filter((f) => present.has(f.name)).map((f) => f.name);
+    const removed = request.mode === "replace" ? [...present].filter((name) => !carried.has(name)) : [];
+    const overwritten = request.mode === "skip" ? [] : collides;
+    const skipped = request.mode === "skip" ? collides : [];
+    const replacesIndex = request.mode === "replace" && index !== null && await this.hasIndexFile(dir);
+    if (!request.confirm && (overwritten.length > 0 || removed.length > 0 || replacesIndex)) {
+      throw new HttpError(
+        409,
+        "memory_import_confirm_required",
+        `This import would overwrite ${overwritten.length} and delete ${removed.length} memories in ${scopeKey}${replacesIndex ? `, and replace its ${MEMORY_INDEX_FILENAME}` : ""}. Repeat it with confirm set.`
+      );
+    }
+    const added = [];
+    for (const file of planned) {
+      if (request.mode === "skip" && present.has(file.name)) continue;
+      await this.writeScopeFile(dir, file.target, file.content);
+      if (!present.has(file.name)) added.push(file.name);
+    }
+    for (const name of removed) {
+      await fs14.unlink(path10.join(dir, name)).catch(() => {
+      });
+    }
+    const written = [...added, ...overwritten];
+    let indexWritten = false;
+    if (index !== null) {
+      if (replacesIndex || !await this.hasIndexFile(dir)) {
+        await this.writeScopeFile(dir, path10.join(dir, MEMORY_INDEX_FILENAME), index);
+        indexWritten = true;
+      } else {
+        indexWritten = await this.extendIndex(dir, index, written);
+      }
+    }
+    for (const name of removed) await this.pruneIndexLines(dir, name);
+    return { scopeKey, mode: request.mode, added, overwritten, skipped, removed, indexWritten };
+  }
+  /**
+   * Appends the document's index lines for the files this import wrote: a line linking a written
+   * file that the scope's index does not already link is added at the end, in the document's own
+   * order. Nothing else is touched — the mirror image of pruneIndexLines, so between them the
+   * index lists neither a file that is gone nor omits one that arrived.
+   */
+  async extendIndex(dir, docIndex, written) {
+    const indexPath = path10.join(dir, MEMORY_INDEX_FILENAME);
+    const current2 = await this.readTextFile(indexPath);
+    if (current2 === null) return false;
+    const docLines = docIndex.split("\n");
+    const additions = [];
+    for (const name of written) {
+      const link = indexLinkPattern(name);
+      if (link.test(current2)) continue;
+      const line = docLines.find((l) => link.test(l));
+      if (line !== void 0 && !additions.includes(line)) additions.push(line);
+    }
+    if (additions.length === 0) return false;
+    const head = current2 === "" || current2.endsWith("\n") ? current2 : `${current2}
+`;
+    await this.writeScopeFile(dir, indexPath, `${head}${additions.join("\n")}
+`);
+    return true;
+  }
+  /**
+   * The write path for imported content, shared by the topic files and the index.
+   *
+   * The target has already been through `resolveFile` (or is the reserved index name, which is
+   * never client-supplied), so it names a file directly inside this scope. The write goes to a
+   * temporary dotfile — invisible to every topic listing — and is renamed over the target, so a
+   * symlink standing at that name is replaced rather than followed out of the Memory directory,
+   * and a reader never sees a half-written memory.
+   */
+  async writeScopeFile(dir, target, content) {
+    const tmp = path10.join(dir, `.import-${randomBytes4(6).toString("hex")}.tmp`);
+    try {
+      await fs14.writeFile(tmp, content, "utf8");
+      await fs14.rename(tmp, target);
+    } catch (err) {
+      await fs14.rm(tmp, { force: true });
+      throw err;
+    }
+  }
+  /** Reads a regular file as text, null when it is absent, unreadable, or not a regular file (lstat, so a symlink is never followed). */
+  async readTextFile(target) {
+    try {
+      if (!(await fs14.lstat(target)).isFile()) return null;
+      return await fs14.readFile(target, "utf8");
+    } catch {
+      return null;
+    }
+  }
   /**
    * 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
@@ -8810,8 +9629,7 @@ var MemoryService = class {
     } catch {
       return;
     }
-    const escaped = fileName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const link = new RegExp(`\\]\\(\\s*<?(?:\\./)?${escaped}>?\\s*(?:"[^"]*"\\s*)?\\)`);
+    const link = indexLinkPattern(fileName);
     const lines = content.split("\n");
     const kept = lines.filter((line) => !link.test(line));
     if (kept.length === lines.length) return;
@@ -9389,7 +10207,7 @@ var BenchmarkService = class {
 };
 
 // src/services/snapshot-service.ts
-import { randomBytes as randomBytes4 } from "crypto";
+import { randomBytes as randomBytes5 } from "crypto";
 import fs17 from "fs/promises";
 import path13 from "path";
 import * as tar from "tar";
@@ -9435,7 +10253,7 @@ var SnapshotService = class {
     } catch {
     }
     await fs17.mkdir(dir, { recursive: true });
-    const tmp = `${file}.tmp-${randomBytes4(4).toString("hex")}`;
+    const tmp = `${file}.tmp-${randomBytes5(4).toString("hex")}`;
     await tar.create(
       {
         gzip: true,
@@ -9463,7 +10281,7 @@ var SnapshotService = class {
   async importArchive(projectId, agentId, archive, confirm) {
     const current2 = await this.currentVersion(projectId, agentId);
     const base = agentDir2(this.root, projectId, agentId);
-    const staging = path13.join(base, `.import-${randomBytes4(6).toString("hex")}`);
+    const staging = path13.join(base, `.import-${randomBytes5(6).toString("hex")}`);
     await fs17.mkdir(staging, { recursive: true });
     try {
       const archiveFile = path13.join(staging, "archive.tar.gz");
@@ -9533,9 +10351,9 @@ var SnapshotService = class {
 import fs18 from "fs/promises";
 import { DEFAULT_PROJECT_ID, projectDir, provisionProjectAgents } from "@prismshadow/penguin-core";
 var ABORT_SETTLE_TIMEOUT_MS = 5e3;
-async function dirExists(path20) {
+async function dirExists(path25) {
   try {
-    const stat = await fs18.stat(path20);
+    const stat = await fs18.stat(path25);
     return stat.isDirectory();
   } catch {
     return false;
@@ -9958,7 +10776,7 @@ var TraceIndexService = class {
   async doReconcile(projectId, agentId, force) {
     const key = `${projectId}\0${agentId}`;
     const dir = tracesDir2(this.root, projectId, agentId);
-    const cached = this.seen.get(key);
+    const cached2 = this.seen.get(key);
     this.counters.gateStats += 1;
     const rootMtime = await statMtime(dir);
     if (rootMtime === null) {
@@ -9966,17 +10784,17 @@ var TraceIndexService = class {
       this.seen.set(key, { root: -1, dates: /* @__PURE__ */ new Map() });
       return;
     }
-    if (!force && cached && cached.root === rootMtime) {
-      const dates = [...cached.dates.keys()].sort();
+    if (!force && cached2 && cached2.root === rootMtime) {
+      const dates = [...cached2.dates.keys()].sort();
       const newest = dates.pop();
       if (newest === void 0) return;
       this.counters.gateStats += 1;
       const newestMtime = await statMtime(path14.join(dir, newest));
-      let changed = newestMtime === null || newestMtime !== cached.dates.get(newest);
+      let changed = newestMtime === null || newestMtime !== cached2.dates.get(newest);
       if (!changed && dates.length > 0) {
         this.counters.gateStats += dates.length;
         const older = await Promise.all(dates.map((d) => statMtime(path14.join(dir, d))));
-        changed = older.some((m, i) => m === null || m !== cached.dates.get(dates[i]));
+        changed = older.some((m, i) => m === null || m !== cached2.dates.get(dates[i]));
       }
       if (!changed) return;
     }
@@ -9994,7 +10812,7 @@ var TraceIndexService = class {
       const m = await statMtime(path14.join(dir, date));
       if (m === null) continue;
       next.dates.set(date, cacheable(m));
-      if (!force && cached?.dates.get(date) === m) continue;
+      if (!force && cached2?.dates.get(date) === m) continue;
       const known = new Map(
         (knownByDate.get(date) ?? []).map((r) => [`${r.sessionId}\0${r.fileIndex}`, r])
       );
@@ -10436,8 +11254,8 @@ import {
   attachedFileLine as attachedFileLine2,
   attachedImageLine,
   isSessionMeta as isSessionMeta6,
-  matchAttachedFileLine,
-  matchAttachedImageLine,
+  matchAttachedFileLine as matchAttachedFileLine2,
+  matchAttachedImageLine as matchAttachedImageLine2,
   modelVisiblePath as modelVisiblePath2,
   parseTraceLines as parseTraceLines2,
   parseUserSteeringText as parseUserSteeringText3,
@@ -10474,12 +11292,12 @@ function rewriteForkText(text, sourceScratchpad, forkScratchpad) {
   };
   return text.split("\n").map((line) => {
     const trimmed = line.trim();
-    const image = matchAttachedImageLine(trimmed);
+    const image = matchAttachedImageLine2(trimmed);
     if (image !== null) {
       const rewritten = rewriteTarget(image);
       return rewritten === null ? line : line.replace(trimmed, attachedImageLine(rewritten));
     }
-    const file = matchAttachedFileLine(trimmed);
+    const file = matchAttachedFileLine2(trimmed);
     if (file !== null) {
       const rewritten = rewriteTarget(file);
       return rewritten === null ? line : line.replace(trimmed, attachedFileLine2(rewritten));
@@ -10531,9 +11349,9 @@ var TraceService = class {
     }));
   }
   /** All shard reads funnel through here (deps.observeShardRead is the windowed-read tests' proof of which files were touched). */
-  async readShard(path20) {
-    this.deps.observeShardRead?.(path20);
-    return readTraceTolerant2(path20);
+  async readShard(path25) {
+    this.deps.observeShardRead?.(path25);
+    return readTraceTolerant2(path25);
   }
   /** 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) {
@@ -10590,8 +11408,8 @@ var TraceService = class {
   }
   /** A child session's concatenated raw shard messages, memoized per request; null = no Trace located. */
   async readChildRaw(projectId, childSid, ctx) {
-    const cached = ctx.raw.get(childSid);
-    if (cached !== void 0) return cached;
+    const cached2 = ctx.raw.get(childSid);
+    if (cached2 !== void 0) return cached2;
     const childAgent = await this.resolveChildAgent(projectId, childSid, ctx);
     let raw = null;
     if (childAgent) {
@@ -10683,11 +11501,11 @@ var TraceService = class {
     const states = [];
     for (let j = 0; j <= upto; j++) {
       const file = files[j];
-      const cached = deserializePrefix(
+      const cached2 = deserializePrefix(
         this.deps.index.repo.getPageStats(projectId, agentId, sessionId, file.index)
       );
-      if (cached !== null) {
-        states.push(cached);
+      if (cached2 !== null) {
+        states.push(cached2);
         continue;
       }
       const state = cloneScanState(j === 0 ? initialScanState() : states[j - 1]);
@@ -10797,16 +11615,16 @@ var TraceService = class {
    * resumes from the selected shard exactly as it would after a restart.
    */
   async forkSessionTrace(projectId, agentId, sourceSessionId, position) {
-    const invalid = (message) => new HttpError(400, "invalid_fork_position", message);
+    const invalid2 = (message) => new HttpError(400, "invalid_fork_position", message);
     const files = await this.locateAll(projectId, agentId, sourceSessionId);
     const targetFilePos = files.findIndex((file) => file.index === position.fileIndex);
-    if (targetFilePos < 0) throw invalid("The selected reply no longer exists in this Session.");
+    if (targetFilePos < 0) throw invalid2("The selected reply no longer exists in this Session.");
     const shards = [];
     for (let i = 0; i <= targetFilePos; i++) shards.push(await this.readShard(files[i].path));
     const targetShard = shards[targetFilePos];
     const target = targetShard[position.ordinal];
     if (!target || !isAssistantText(target)) {
-      throw invalid("The fork position must identify a completed assistant reply.");
+      throw invalid2("The fork position must identify a completed assistant reply.");
     }
     let inCompaction = false;
     for (let filePos = 0; filePos <= targetFilePos; filePos++) {
@@ -10821,7 +11639,7 @@ var TraceService = class {
         }
       }
     }
-    if (inCompaction) throw invalid("A compaction summary cannot be used as a fork point.");
+    if (inCompaction) throw invalid2("A compaction summary cannot be used as a fork point.");
     let cutOrdinal = position.ordinal + 1;
     let completedRequest = false;
     for (let i = position.ordinal + 1; i < targetShard.length; i++) {
@@ -10831,21 +11649,21 @@ var TraceService = class {
         break;
       }
       if (isAssistantText(msg)) {
-        throw invalid("The selected record is not the final assistant reply of its Task.");
+        throw invalid2("The selected record is not the final assistant reply of its Task.");
       }
       cutOrdinal = i + 1;
       if (msg.type === "event_msg" && p.type === "request_end") {
         if (p.status === "completed") completedRequest = true;
-        else throw invalid("The selected assistant reply belongs to an incomplete request.");
+        else throw invalid2("The selected assistant reply belongs to an incomplete request.");
       }
     }
-    if (!completedRequest) throw invalid("The selected assistant reply has not completed yet.");
+    if (!completedRequest) throw invalid2("The selected assistant reply has not completed yet.");
     const resumed = resumeTrace(targetShard.slice(0, cutOrdinal));
     if (resumed.contextClosed || resumed.carryOver.length > 0 || !resumed.history.some((message) => message === target)) {
-      throw invalid("The selected reply is not a complete resumable Task boundary.");
+      throw invalid2("The selected reply is not a complete resumable Task boundary.");
     }
     const firstMeta = shards.flat().find(isSessionMeta6);
-    if (!firstMeta) throw invalid("The source Trace has no session metadata.");
+    if (!firstMeta) throw invalid2("The source Trace has no session metadata.");
     const created = /* @__PURE__ */ new Date();
     const createdAt = created.toISOString();
     const newSessionId = forkSessionId(created);
@@ -10898,7 +11716,7 @@ var TraceService = class {
         const limit = filePos === targetFilePos ? cutOrdinal : sourceMessages.length;
         const records = sourceMessages.slice(0, limit).map(rewrite);
         if (!isSessionMeta6(records[0])) {
-          throw invalid(`Trace shard ${sourceFile.index} does not start with session metadata.`);
+          throw invalid2(`Trace shard ${sourceFile.index} does not start with session metadata.`);
         }
         const dir = path15.join(tracesDir3(this.root, projectId, agentId), sourceFile.date);
         await fs20.mkdir(dir, { recursive: true });
@@ -11375,20 +12193,20 @@ var TraceService = class {
    * import round-trip lands in the same date dir on non-UTC servers.
    */
   async importTraceFile(projectId, agentId, content) {
-    const invalid = (message) => new HttpError(400, "invalid_trace", message);
+    const invalid2 = (message) => new HttpError(400, "invalid_trace", message);
     let records;
     try {
       records = parseTraceLines2(content, { onMalformed: "throw" });
     } catch {
-      throw invalid("The file is not valid Trace JSONL.");
+      throw invalid2("The file is not valid Trace JSONL.");
     }
-    if (records.length === 0) throw invalid("The file contains no Trace records.");
+    if (records.length === 0) throw invalid2("The file contains no Trace records.");
     const first = records[0];
     if (!isSessionMeta6(first))
-      throw invalid("The first record of a Trace file must be session_meta.");
+      throw invalid2("The first record of a Trace file must be session_meta.");
     const sessionId = first.payload.session_id;
     if (typeof sessionId !== "string" || !IMPORT_SESSION_ID_RE.test(sessionId)) {
-      throw invalid("session_meta carries a missing or invalid session_id.");
+      throw invalid2("session_meta carries a missing or invalid session_id.");
     }
     const duplicate = () => new HttpError(
       409,
@@ -11525,7 +12343,7 @@ var UpdateCheckService = class {
 };
 
 // src/services/usage-service.ts
-var ERROR_RECENT_N = 20;
+var ERROR_RECENT_N = 10;
 function costOf(sums, rates) {
   return (sums.cacheRead * rates.cacheRead + sums.cacheWrite * rates.cacheWrite + sums.output * rates.output) / 1e6;
 }
@@ -11554,23 +12372,59 @@ var UsageService = class {
       ...from !== void 0 ? { from } : {},
       ...to !== void 0 ? { to } : {}
     });
+    const ts = {
+      ...q.fromTs !== void 0 ? { fromTs: q.fromTs } : {},
+      ...q.toTs !== void 0 ? { toTs: q.toTs } : {}
+    };
     const todayRows = this.usage.bucketByModel(projectId, win(today, today));
     const last7dRows = this.usage.bucketByModel(projectId, win(localDateMinusDays(this.now(), 6)));
-    const totalRows = this.usage.bucketByModel(projectId, win(q.from, q.to));
-    const groupRows = this.usage.groupsByModel(projectId, q.groupBy, win(q.from, q.to));
-    const trendFrom = localDateMinusDays(this.now(), 29);
-    const trendRows = this.usage.groupsByModel(projectId, "date", win(trendFrom));
-    const agentRows = this.usage.groupsByModel(projectId, "agent", {
+    const totalRows = this.usage.bucketByModel(projectId, { ...win(q.from, q.to), ...ts });
+    const groupRows = this.usage.groupsByModel(projectId, q.groupBy, {
+      ...win(q.from, q.to),
+      ...ts
+    });
+    const granularity = q.granularity ?? "day";
+    const seriesFrom = q.from ?? localDateMinusDays(this.now(), 29);
+    const seriesTo = q.to ?? today;
+    let bucketKeys;
+    if (granularity === "minute" || granularity === "hour" && ts.fromTs !== void 0) {
+      if (ts.fromTs === void 0 || ts.toTs === void 0) {
+        throw badRequest(
+          "fromTs and toTs must be given together, and minute granularity requires them."
+        );
+      }
+      bucketKeys = enumerateTsBuckets(new Date(ts.fromTs), new Date(ts.toTs), granularity, 500);
+    } else {
+      bucketKeys = enumerateBuckets(seriesFrom, seriesTo, granularity, 500);
+    }
+    if (bucketKeys.length > 500) {
+      throw badRequest(
+        "Date range too wide for this granularity; narrow the range or coarsen the granularity."
+      );
+    }
+    const seriesRows = this.usage.seriesByModel(projectId, granularity, {
+      ...win(seriesFrom, seriesTo),
+      ...ts
+    });
+    const agentFree = {
       ...q.provider !== void 0 ? { provider: q.provider } : {},
       ...q.modelId !== void 0 ? { modelId: q.modelId } : {},
       ...q.from !== void 0 ? { from: q.from } : {},
-      ...q.to !== void 0 ? { to: q.to } : {}
+      ...q.to !== void 0 ? { to: q.to } : {},
+      ...ts
+    };
+    const agentBucketRows = this.usage.agentSeries(projectId, granularity, {
+      ...agentFree,
+      from: seriesFrom,
+      to: seriesTo
     });
-    const statusRows = this.usage.statusByModel(projectId, {
+    const modelFiltered = q.provider !== void 0 || q.modelId !== void 0;
+    const modelBucketRows = modelFiltered ? this.usage.seriesByModel(projectId, granularity, {
       ...q.agentId !== void 0 ? { agentId: q.agentId } : {},
-      ...q.from !== void 0 ? { from: q.from } : {},
-      ...q.to !== void 0 ? { to: q.to } : {}
-    });
+      from: seriesFrom,
+      to: seriesTo,
+      ...ts
+    }) : seriesRows;
     const errorFilter = {
       ...q.agentId !== void 0 ? { agentId: q.agentId } : {},
       ...q.from !== void 0 ? { from: q.from } : {},
@@ -11580,19 +12434,12 @@ var UsageService = class {
     };
     const rates = /* @__PURE__ */ new Map();
     const allRefs = /* @__PURE__ */ new Map();
-    for (const r of [...todayRows, ...last7dRows, ...totalRows, ...groupRows, ...trendRows]) {
+    for (const r of [...todayRows, ...last7dRows, ...totalRows, ...groupRows, ...seriesRows]) {
       allRefs.set(refKey2(r.provider, r.modelId), { provider: r.provider, modelId: r.modelId });
     }
     for (const [key, ref] of allRefs) {
       rates.set(key, await this.lookupPricing(projectId, ref.provider, ref.modelId));
     }
-    const byAgentMap = /* @__PURE__ */ new Map();
-    for (const r of agentRows) {
-      const acc = byAgentMap.get(r.key) ?? { requests: 0, total: 0 };
-      acc.requests += r.requests;
-      acc.total += r.total;
-      byAgentMap.set(r.key, acc);
-    }
     return {
       summary: {
         today: this.foldBucket(todayRows, rates),
@@ -11601,9 +12448,10 @@ var UsageService = class {
       },
       groupBy: q.groupBy,
       groups: this.foldGroups(groupRows, rates, q.groupBy),
-      trend: this.foldTrend(trendRows, rates),
-      byAgent: [...byAgentMap.entries()].map(([agentId, v]) => ({ agentId, requests: v.requests, total: v.total })).sort((a, b) => b.requests - a.requests),
-      success: statusRows.sort((a, b) => b.total - a.total),
+      granularity,
+      series: this.foldSeries(bucketKeys, seriesRows, rates),
+      byAgentSeries: foldAgentSeries(bucketKeys, agentBucketRows),
+      byModelSeries: foldModelSeries(bucketKeys, modelBucketRows),
       errors: this.foldErrors(projectId, errorFilter),
       agentIds: this.usage.distinctAgentIds(projectId),
       models: this.usage.distinctModels(projectId)
@@ -11690,40 +12538,102 @@ var UsageService = class {
     else out.sort((a, b) => b.total - a.total);
     return out;
   }
-  foldTrend(rows, rates) {
-    const byDate = /* @__PURE__ */ new Map();
+  /**
+   * Fold the per-Model series rows onto the zero-filled bucket skeleton: every
+   * enumerated bucket appears exactly once, in order, so line charts never
+   * connect across a silent gap. A row whose key falls outside the skeleton
+   * cannot happen for day/week/month (keys derive from the filtered date
+   * column) and is dropped defensively for minute/hour, whose keys come from
+   * `ts` and can therefore fall outside a skeleton built from `date` if a row
+   * was recorded under a different clock.
+   */
+  foldSeries(keys, rows, rates) {
+    const byKey = new Map(
+      keys.map((bucket) => [
+        bucket,
+        {
+          bucket,
+          cacheRead: 0,
+          cacheWrite: 0,
+          output: 0,
+          total: 0,
+          cost: null,
+          requests: 0,
+          completed: 0,
+          denominator: 0
+        }
+      ])
+    );
     for (const r of rows) {
-      const acc = byDate.get(r.key) ?? {
-        total: 0,
-        cacheRead: 0,
-        cacheWrite: 0,
-        output: 0,
-        cost: null
-      };
-      acc.total += r.total;
+      const acc = byKey.get(r.key);
+      if (!acc) continue;
       acc.cacheRead += r.cacheRead;
       acc.cacheWrite += r.cacheWrite;
       acc.output += r.output;
+      acc.total += r.total;
+      acc.requests += r.requests;
+      acc.completed += r.completed;
+      acc.denominator += r.denominator;
       const rate = rates.get(refKey2(r.provider, r.modelId));
       if (rate) acc.cost = (acc.cost ?? 0) + costOf(r, rate);
-      byDate.set(r.key, acc);
     }
-    return [...byDate.entries()].sort((a, b) => a[0].localeCompare(b[0])).map(([date, v]) => ({
-      date,
-      total: v.total,
-      cacheRead: v.cacheRead,
-      cacheWrite: v.cacheWrite,
-      output: v.output,
-      cost: v.cost
-    }));
+    return keys.map((k) => byKey.get(k));
   }
 };
+var sumOf = (a) => a.reduce((s, v) => s + v, 0);
+var zeros = (n) => new Array(n).fill(0);
+function foldAgentSeries(keys, rows) {
+  const idx = new Map(keys.map((k, i) => [k, i]));
+  const byAgent = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    const i = idx.get(r.key);
+    if (i === void 0) continue;
+    let s = byAgent.get(r.agentId);
+    if (!s) {
+      s = {
+        agentId: r.agentId,
+        requests: zeros(keys.length),
+        completed: zeros(keys.length),
+        denominator: zeros(keys.length)
+      };
+      byAgent.set(r.agentId, s);
+    }
+    s.requests[i] += r.requests;
+    s.completed[i] += r.completed;
+    s.denominator[i] += r.denominator;
+  }
+  return [...byAgent.values()].sort((a, b) => sumOf(b.requests) - sumOf(a.requests));
+}
+function foldModelSeries(keys, rows) {
+  const idx = new Map(keys.map((k, i) => [k, i]));
+  const byModel = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    const i = idx.get(r.key);
+    if (i === void 0) continue;
+    const key = refKey2(r.provider, r.modelId);
+    let s = byModel.get(key);
+    if (!s) {
+      s = {
+        provider: r.provider,
+        modelId: r.modelId,
+        requests: zeros(keys.length),
+        completed: zeros(keys.length),
+        denominator: zeros(keys.length)
+      };
+      byModel.set(key, s);
+    }
+    s.requests[i] += r.requests;
+    s.completed[i] += r.completed;
+    s.denominator[i] += r.denominator;
+  }
+  return [...byModel.values()].sort((a, b) => sumOf(b.requests) - sumOf(a.requests));
+}
 
 // src/hmr/host.ts
-import crypto from "crypto";
-import fs21 from "fs";
-import fsp from "fs/promises";
-import path16 from "path";
+import crypto2 from "crypto";
+import fs22 from "fs";
+import fsp2 from "fs/promises";
+import path21 from "path";
 import zlib from "zlib";
 import { pathToFileURL } from "url";
 import { boot, initialDoc, upgrade } from "@prismshadow/penguin-core/kernel";
@@ -11757,21 +12667,1148 @@ var HotResources = class {
 
 // src/platform/platform.ts
 import { defineIface, schema, type } from "@prismshadow/penguin-core/kernel";
+
+// src/platform/terminal/manager.ts
+import fsp from "fs/promises";
+import path20 from "path";
+
+// src/terminal/spawn-helper.ts
+import fs21 from "fs";
+import path16 from "path";
+import { createRequire } from "module";
+var EXEC_BITS = 73;
+function repairSpawnHelpers(pkgDir, arch = process.arch) {
+  const candidates = [
+    path16.join(pkgDir, "build", "Release", "spawn-helper"),
+    path16.join(pkgDir, "build", "Debug", "spawn-helper"),
+    path16.join(pkgDir, "prebuilds", `darwin-${arch}`, "spawn-helper")
+  ];
+  const repaired = [];
+  for (const helper of candidates) {
+    let mode;
+    try {
+      mode = fs21.statSync(helper).mode;
+    } catch {
+      continue;
+    }
+    if ((mode & EXEC_BITS) !== 0) continue;
+    try {
+      fs21.chmodSync(helper, mode | EXEC_BITS);
+      repaired.push(helper);
+    } catch {
+    }
+  }
+  return repaired;
+}
+function nodePtyDir() {
+  try {
+    return path16.dirname(createRequire(import.meta.url).resolve("node-pty/package.json"));
+  } catch {
+    return null;
+  }
+}
+var repairAttempted = false;
+function ensureSpawnHelperExecutable() {
+  if (process.platform !== "darwin" || repairAttempted) return;
+  repairAttempted = true;
+  const pkgDir = nodePtyDir();
+  if (pkgDir === null) return;
+  for (const fixed of repairSpawnHelpers(pkgDir)) {
+    console.log(`[terminal] restored the exec bit on ${fixed} (node-pty ships it as 0644)`);
+  }
+}
+function spawnHelperHint() {
+  if (process.platform !== "darwin") return null;
+  const pkgDir = nodePtyDir();
+  if (pkgDir === null) return null;
+  for (const helper of [
+    path16.join(pkgDir, "build", "Release", "spawn-helper"),
+    path16.join(pkgDir, "prebuilds", `darwin-${process.arch}`, "spawn-helper")
+  ]) {
+    try {
+      if ((fs21.statSync(helper).mode & EXEC_BITS) === 0) {
+        return `${helper} is not executable \u2014 run: chmod +x "${helper}"`;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+
+// src/platform/terminal/session.ts
+import os2 from "os";
+import path19 from "path";
+import { randomUUID as randomUUID4 } from "crypto";
+import xterm from "@xterm/headless";
+
+// src/platform/terminal/pty-module.ts
+import { createRequire as createRequire2 } from "module";
+import path17 from "path";
+var cached = null;
+function loadNodePty(resources) {
+  if (cached !== null) return cached;
+  const attempts = [
+    // Packaged server: this module is part of the runtime's own graph.
+    () => createRequire2(import.meta.url)("node-pty"),
+    // Pushed bundle: the binary rides along as an asset, laid out as a real package dir.
+    () => {
+      const dir = resources.claim(ASSETS_RESOURCE_ID);
+      if (dir === void 0) throw new Error("no assets directory published");
+      return createRequire2(path17.join(dir, "index.mjs"))("node-pty");
+    }
+  ];
+  const failures = [];
+  for (const attempt of attempts) {
+    try {
+      cached = attempt();
+      return cached;
+    } catch (err) {
+      failures.push(err instanceof Error ? err.message : String(err));
+    }
+  }
+  throw new Error(`node-pty is unavailable to the platform: ${failures.join(" / ")}`);
+}
+
+// src/platform/terminal/shell.ts
+import { spawnSync } from "child_process";
+import path18 from "path";
+function shellName(shell) {
+  return path18.win32.basename(shell).replace(/\.(exe|cmd|bat)$/i, "").toLowerCase();
+}
+function defaultOnPath(cmd) {
+  try {
+    const res = spawnSync("where", [cmd], {
+      stdio: ["ignore", "pipe", "ignore"],
+      windowsHide: true
+    });
+    return res.status === 0 && (res.stdout?.toString("utf8").trim().length ?? 0) > 0;
+  } catch {
+    return false;
+  }
+}
+function resolveDefaultShell(env = process.env, platform = process.platform, opts = {}) {
+  const explicit = env.PENGUIN_SHELL?.trim();
+  if (explicit) return explicit;
+  if (platform !== "win32") return env.SHELL || "/bin/sh";
+  const onPath = opts.onPath ?? defaultOnPath;
+  if (onPath("pwsh")) return "pwsh.exe";
+  if (onPath("powershell")) return "powershell.exe";
+  return env.ComSpec || env.COMSPEC || "C:\\Windows\\System32\\cmd.exe";
+}
+function shellArgs(shell) {
+  const name = shellName(shell);
+  if (name === "pwsh" || name === "powershell") return ["-NoLogo"];
+  if (name === "cmd") return [];
+  return ["-l"];
+}
+var cachedDefault = null;
+function defaultTerminalShell() {
+  if (cachedDefault === null) cachedDefault = resolveDefaultShell();
+  return cachedDefault;
+}
+
+// src/platform/terminal/input-mode.ts
+var TRACKED_MODES = /* @__PURE__ */ new Set([
+  1,
+  // DECCKM, application cursor keys
+  7,
+  // DECAWM, auto-wrap
+  12,
+  // cursor blink
+  25,
+  // DECTCEM, cursor visibility
+  66,
+  // DECNKM, application keypad
+  1e3,
+  // mouse: click tracking
+  1002,
+  // mouse: button-event tracking
+  1003,
+  // mouse: any-event tracking
+  1004,
+  // focus reporting
+  1005,
+  // mouse: utf-8 coordinates
+  1006,
+  // mouse: SGR coordinates
+  1015,
+  // mouse: urxvt coordinates
+  1016,
+  // mouse: SGR pixel coordinates
+  2004
+  // bracketed paste
+]);
+var DEFAULT_ON = /* @__PURE__ */ new Set([7, 25]);
+var MAX_CARRY = 64;
+var DEC_PRIVATE_MODE_PATTERN = /\x1b\[\?([0-9;]*)([hl])/g;
+var TerminalInputModeTracker = class {
+  enabled = new Set(DEFAULT_ON);
+  /** Tail of the previous chunk that may hold the start of a split escape sequence. */
+  carry = "";
+  feed(chunk) {
+    const text = this.carry + chunk;
+    DEC_PRIVATE_MODE_PATTERN.lastIndex = 0;
+    let match;
+    let lastEnd = 0;
+    while ((match = DEC_PRIVATE_MODE_PATTERN.exec(text)) !== null) {
+      lastEnd = match.index + match[0].length;
+      const on = match[2] === "h";
+      for (const raw of (match[1] ?? "").split(";")) {
+        if (raw === "") continue;
+        const mode = Number.parseInt(raw, 10);
+        if (!TRACKED_MODES.has(mode)) continue;
+        if (on) this.enabled.add(mode);
+        else this.enabled.delete(mode);
+      }
+    }
+    const tailStart = Math.max(lastEnd, text.length - MAX_CARRY);
+    const tail = text.slice(tailStart);
+    const escIndex = tail.lastIndexOf("\x1B");
+    this.carry = escIndex === -1 ? "" : tail.slice(escIndex);
+  }
+  isEnabled(mode) {
+    return this.enabled.has(mode);
+  }
+  /**
+   * Escape sequences that put a freshly attached client back into the modes the running
+   * program believes it is in. Emitted right after the restored screen content.
+   */
+  preamble() {
+    const on = [];
+    const off = [];
+    for (const mode of TRACKED_MODES) {
+      const enabled = this.enabled.has(mode);
+      if (enabled === DEFAULT_ON.has(mode)) continue;
+      (enabled ? on : off).push(mode);
+    }
+    let out = "";
+    if (on.length > 0) out += `\x1B[?${on.join(";")}h`;
+    if (off.length > 0) out += `\x1B[?${off.join(";")}l`;
+    return out;
+  }
+};
+
+// src/platform/terminal/snapshot.ts
+var DEFAULT_RESTORE_SCROLLBACK_LINES = 400;
+var MAX_RESTORE_SCROLLBACK_LINES = 2e3;
+function styleOf(cell) {
+  const params = [];
+  if (cell.isBold()) params.push("1");
+  if (cell.isDim()) params.push("2");
+  if (cell.isItalic()) params.push("3");
+  if (cell.isUnderline()) params.push("4");
+  if (cell.isBlink()) params.push("5");
+  if (cell.isInverse()) params.push("7");
+  if (cell.isInvisible()) params.push("8");
+  if (cell.isStrikethrough()) params.push("9");
+  if (cell.isOverline()) params.push("53");
+  if (cell.isFgRGB()) {
+    const rgb = cell.getFgColor();
+    params.push(`38;2;${rgb >> 16 & 255};${rgb >> 8 & 255};${rgb & 255}`);
+  } else if (cell.isFgPalette()) {
+    params.push(`38;5;${cell.getFgColor()}`);
+  }
+  if (cell.isBgRGB()) {
+    const rgb = cell.getBgColor();
+    params.push(`48;2;${rgb >> 16 & 255};${rgb >> 8 & 255};${rgb & 255}`);
+  } else if (cell.isBgPalette()) {
+    params.push(`48;5;${cell.getBgColor()}`);
+  }
+  return params.join(";");
+}
+function isUntouched(cell) {
+  return cell.getChars() === "" && cell.isAttributeDefault();
+}
+function renderLine(line, cols, scratch) {
+  let lastMeaningful = -1;
+  for (let x = 0; x < cols; x += 1) {
+    const cell = line.getCell(x, scratch);
+    if (cell && !isUntouched(cell)) lastMeaningful = x;
+  }
+  if (lastMeaningful === -1) return "";
+  let out = "";
+  let currentStyle = "";
+  for (let x = 0; x <= lastMeaningful; x += 1) {
+    const cell = line.getCell(x, scratch);
+    if (!cell) continue;
+    const width = cell.getWidth();
+    if (width === 0) continue;
+    const style = styleOf(cell);
+    if (style !== currentStyle) {
+      out += style === "" ? "\x1B[0m" : `\x1B[0;${style}m`;
+      currentStyle = style;
+    }
+    const chars = cell.getChars();
+    out += chars === "" ? " " : chars;
+  }
+  if (currentStyle !== "") out += "\x1B[0m";
+  return out;
+}
+function renderRestoreAnsi(terminal, options = {}) {
+  const buffer = terminal.buffer.active;
+  const scratch = buffer.getNullCell();
+  const rows = terminal.rows;
+  const cols = terminal.cols;
+  const isAlternate = buffer.type === "alternate";
+  const requested = Math.min(
+    Math.max(options.scrollbackLines ?? DEFAULT_RESTORE_SCROLLBACK_LINES, 0),
+    MAX_RESTORE_SCROLLBACK_LINES
+  );
+  const scrollbackLines = isAlternate ? 0 : Math.min(requested, buffer.baseY);
+  const firstLine = buffer.baseY - scrollbackLines;
+  const lastLine = buffer.baseY + rows - 1;
+  const parts = [];
+  parts.push("\x1B[0m\x1B[?1049l\x1B[H\x1B[2J\x1B[3J");
+  if (isAlternate) parts.push("\x1B[?1049h\x1B[H");
+  for (let y = firstLine; y <= lastLine; y += 1) {
+    if (y > firstLine) parts.push("\r\n");
+    const line = buffer.getLine(y);
+    if (line) parts.push(renderLine(line, cols, scratch));
+  }
+  parts.push(`\x1B[${buffer.cursorY + 1};${buffer.cursorX + 1}H`);
+  if (options.inputModePreamble) parts.push(options.inputModePreamble);
+  return parts.join("");
+}
+function resolveIndex(value, total, fallback) {
+  if (total === 0) return fallback === "start" ? 0 : -1;
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return fallback === "start" ? 0 : total - 1;
+  }
+  const resolved = value < 0 ? total + value : value;
+  if (resolved < 0) return 0;
+  if (resolved >= total) return total - 1;
+  return resolved;
+}
+function captureLines(terminal, options = {}) {
+  const buffer = terminal.buffer.active;
+  const totalLines = buffer.baseY + terminal.rows;
+  const all = [];
+  for (let y = 0; y < totalLines; y += 1) {
+    all.push(buffer.getLine(y)?.translateToString(true) ?? "");
+  }
+  const startIndex = resolveIndex(options.start, totalLines, "start");
+  const endIndex = resolveIndex(options.end, totalLines, "end");
+  if (totalLines === 0 || startIndex > endIndex) return { lines: [], totalLines };
+  return { lines: all.slice(startIndex, endIndex + 1), totalLines };
+}
+
+// src/platform/terminal/size-ownership.ts
+function applyTerminalSize(state, request) {
+  if (request.intent === "update" && state.ownerId !== request.connectionId) {
+    return { state, apply: false };
+  }
+  const nextState = {
+    ownerId: request.connectionId,
+    cols: request.cols,
+    rows: request.rows
+  };
+  const unchanged = state.cols === request.cols && state.rows === request.rows;
+  return { state: nextState, apply: !unchanged };
+}
+function releaseTerminalSize(state, connectionId) {
+  return state.ownerId === connectionId ? { ...state, ownerId: null } : state;
+}
+
+// src/platform/terminal/session.ts
+var { Terminal: HeadlessTerminal } = xterm;
+var DEFAULT_COLS = 80;
+var DEFAULT_ROWS = 24;
+var SCROLLBACK_LINES = 5e3;
+var TITLE_DEBOUNCE_MS = 150;
+var EXIT_OUTPUT_LINE_LIMIT = 12;
+var OSC_COLOR_QUERY_RESPONSES = /* @__PURE__ */ new Map([
+  [10, "rgb:e6e6/e6e6/e6e6"],
+  // foreground
+  [11, "rgb:1414/1717/1a1a"],
+  // background
+  [12, "rgb:e6e6/e6e6/e6e6"]
+  // cursor
+]);
+function buildTerminalEnv(extra, cwd) {
+  const env = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (typeof value === "string") env[key] = value;
+  }
+  Object.assign(env, extra ?? {});
+  env.TERM = "xterm-256color";
+  env.COLORTERM = "truecolor";
+  env.PENGUIN_TERMINAL = "1";
+  env.PWD = cwd;
+  delete env.NODE_OPTIONS;
+  return env;
+}
+var TerminalSession = class {
+  id;
+  seq;
+  cwd;
+  ownerUserId;
+  createdAt = /* @__PURE__ */ new Date();
+  name;
+  terminal;
+  ptyProcess;
+  inputMode = new TerminalInputModeTracker();
+  outputListeners = /* @__PURE__ */ new Set();
+  exitListeners = /* @__PURE__ */ new Set();
+  titleListeners = /* @__PURE__ */ new Set();
+  title = null;
+  pendingTitle = null;
+  titleTimer = null;
+  sizeState;
+  exitInfo = null;
+  disposed = false;
+  constructor(options) {
+    this.id = options.id ?? randomUUID4();
+    this.seq = options.seq ?? 1;
+    this.cwd = options.cwd;
+    this.ownerUserId = options.ownerUserId;
+    this.name = options.name ?? (path19.basename(options.cwd) || "terminal");
+    const cols = clampDimension(options.cols, DEFAULT_COLS, 1e3);
+    const rows = clampDimension(options.rows, DEFAULT_ROWS, 500);
+    this.sizeState = { ownerId: null, cols, rows };
+    this.terminal = new HeadlessTerminal({
+      cols,
+      rows,
+      scrollback: SCROLLBACK_LINES,
+      allowProposedApi: true
+    });
+    const shell = options.shell ?? defaultTerminalShell();
+    ensureSpawnHelperExecutable();
+    this.ptyProcess = loadNodePty(options.resources).spawn(shell, shellArgs(shell), {
+      name: "xterm-256color",
+      cols,
+      rows,
+      cwd: options.cwd,
+      env: buildTerminalEnv(options.env, options.cwd)
+    });
+    this.registerCapabilityResponders();
+    this.terminal.onTitleChange((next) => {
+      this.pendingTitle = next.trim() || null;
+      if (this.titleTimer) return;
+      this.titleTimer = setTimeout(() => {
+        this.titleTimer = null;
+        if (this.pendingTitle === this.title) return;
+        this.title = this.pendingTitle;
+        for (const listener of [...this.titleListeners]) safely(() => listener(this.title));
+      }, TITLE_DEBOUNCE_MS);
+    });
+    this.ptyProcess.onData((chunk) => {
+      this.inputMode.feed(chunk);
+      this.terminal.write(chunk, () => {
+        for (const listener of [...this.outputListeners]) safely(() => listener(chunk));
+      });
+    });
+    this.ptyProcess.onExit(({ exitCode, signal }) => {
+      const finalize = () => {
+        if (this.exitInfo) return;
+        this.exitInfo = {
+          exitCode,
+          signal: signal ?? null,
+          lastOutputLines: this.disposed ? [] : lastNonEmptyLines(this.terminal, EXIT_OUTPUT_LINE_LIMIT)
+        };
+        for (const listener of [...this.exitListeners]) safely(() => listener(this.exitInfo));
+      };
+      if (this.disposed) return finalize();
+      this.terminal.write("", finalize);
+    });
+  }
+  /** DA1 / DSR / OSC colour queries — see OSC_COLOR_QUERY_RESPONSES. */
+  registerCapabilityResponders() {
+    this.terminal.parser.registerCsiHandler({ final: "c" }, (params) => {
+      if (params.length === 0 || params.length === 1 && params[0] === 0) {
+        this.ptyProcess.write("\x1B[?62;4;22c");
+        return true;
+      }
+      return false;
+    });
+    this.terminal.parser.registerCsiHandler({ final: "n" }, (params) => {
+      if (params.length !== 1) return false;
+      if (params[0] === 5) {
+        this.ptyProcess.write("\x1B[0n");
+        return true;
+      }
+      if (params[0] === 6) {
+        const buffer = this.terminal.buffer.active;
+        this.ptyProcess.write(`\x1B[${buffer.cursorY + 1};${buffer.cursorX + 1}R`);
+        return true;
+      }
+      return false;
+    });
+    this.terminal.parser.registerCsiHandler({ prefix: "?", final: "n" }, (params) => {
+      if (params.length !== 1 || params[0] !== 6) return false;
+      const buffer = this.terminal.buffer.active;
+      this.ptyProcess.write(`\x1B[?${buffer.cursorY + 1};${buffer.cursorX + 1}R`);
+      return true;
+    });
+    for (const [code, response] of OSC_COLOR_QUERY_RESPONSES) {
+      this.terminal.parser.registerOscHandler(code, (data) => {
+        if (data.trim() !== "?") return false;
+        this.ptyProcess.write(`\x1B]${code};${response}\x1B\\`);
+        return true;
+      });
+    }
+  }
+  get alive() {
+    return this.exitInfo === null && !this.disposed;
+  }
+  get exit() {
+    return this.exitInfo;
+  }
+  info() {
+    return {
+      id: this.id,
+      seq: this.seq,
+      name: this.name,
+      cwd: this.cwd,
+      ownerUserId: this.ownerUserId,
+      title: this.title,
+      cols: this.sizeState.cols,
+      rows: this.sizeState.rows,
+      pid: this.ptyProcess.pid,
+      createdAt: this.createdAt.toISOString(),
+      alive: this.alive,
+      exit: this.exitInfo
+    };
+  }
+  rename(name) {
+    const trimmed = name.trim();
+    if (trimmed) this.name = trimmed;
+  }
+  write(data) {
+    if (!this.alive) return;
+    this.ptyProcess.write(data);
+  }
+  /**
+   * Applies a size request under the claim/update ownership rule, resizing both the pty and
+   * the daemon's emulator so snapshots keep matching what the shell laid out.
+   */
+  resize(request) {
+    const cols = clampDimension(request.cols, DEFAULT_COLS, 1e3);
+    const rows = clampDimension(request.rows, DEFAULT_ROWS, 500);
+    const decision = applyTerminalSize(this.sizeState, { ...request, cols, rows });
+    this.sizeState = decision.state;
+    if (!decision.apply || !this.alive) return false;
+    this.terminal.resize(cols, rows);
+    try {
+      this.ptyProcess.resize(cols, rows);
+    } catch {
+    }
+    return true;
+  }
+  releaseSize(connectionId) {
+    this.sizeState = releaseTerminalSize(this.sizeState, connectionId);
+  }
+  get size() {
+    return { cols: this.sizeState.cols, rows: this.sizeState.rows };
+  }
+  /** The attach payload: the whole screen as an ANSI stream (see snapshot.ts). */
+  restoreStream(options = {}) {
+    return renderRestoreAnsi(this.terminal, {
+      ...options,
+      inputModePreamble: this.inputMode.preamble()
+    });
+  }
+  capture(options = {}) {
+    return captureLines(this.terminal, options);
+  }
+  onOutput(listener) {
+    this.outputListeners.add(listener);
+    return () => this.outputListeners.delete(listener);
+  }
+  onExit(listener) {
+    this.exitListeners.add(listener);
+    return () => this.exitListeners.delete(listener);
+  }
+  onTitleChange(listener) {
+    this.titleListeners.add(listener);
+    return () => this.titleListeners.delete(listener);
+  }
+  kill(signal) {
+    if (!this.alive) return;
+    try {
+      this.ptyProcess.kill(signal);
+    } catch {
+    }
+  }
+  dispose() {
+    if (this.disposed) return;
+    if (this.titleTimer) clearTimeout(this.titleTimer);
+    this.kill();
+    this.disposed = true;
+    if (process.platform !== "win32" && this.exitInfo === null) {
+      try {
+        this.ptyProcess.kill("SIGKILL");
+      } catch {
+      }
+    }
+    this.outputListeners.clear();
+    this.exitListeners.clear();
+    this.titleListeners.clear();
+    this.terminal.dispose();
+  }
+};
+function clampDimension(value, fallback, max) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+  return Math.min(Math.max(Math.trunc(value), 1), max);
+}
+function lastNonEmptyLines(terminal, limit) {
+  const buffer = terminal.buffer.active;
+  const total = buffer.baseY + terminal.rows;
+  const lines = [];
+  for (let y = total - 1; y >= 0 && lines.length < limit; y -= 1) {
+    const text = buffer.getLine(y)?.translateToString(true) ?? "";
+    if (text.trim() === "" && lines.length === 0) continue;
+    lines.push(text);
+  }
+  return lines.reverse();
+}
+function safely(fn) {
+  try {
+    fn();
+  } catch {
+  }
+}
+function expandHomePath(input) {
+  if (input === "~") return os2.homedir();
+  if (input.startsWith("~/")) return path19.join(os2.homedir(), input.slice(2));
+  return input;
+}
+
+// src/platform/terminal/manager.ts
+var EXITED_SESSION_GRACE_MS = 5 * 60 * 1e3;
+var MAX_TERMINALS_PER_USER = 12;
+var TerminalManager = class {
+  /**
+   * The kernel's resource registry, threaded to every session it creates: a native module
+   * reaches the platform through it (pty-module.ts), and live ptys are registered in it so
+   * a hot swap hands them to the next platform instead of killing them.
+   */
+  constructor(resources, graceMs = EXITED_SESSION_GRACE_MS) {
+    this.resources = resources;
+    this.graceMs = graceMs;
+  }
+  resources;
+  graceMs;
+  sessions = /* @__PURE__ */ new Map();
+  reapTimers = /* @__PURE__ */ new Map();
+  async create(request) {
+    const cwd = await resolveCwd(request.cwd);
+    const owned = this.list(request.ownerUserId).filter((session2) => session2.alive);
+    if (owned.length >= MAX_TERMINALS_PER_USER) {
+      throw new HttpError(
+        429,
+        "terminal_limit_reached",
+        `You already have ${MAX_TERMINALS_PER_USER} open terminals. Close one first.`
+      );
+    }
+    let name = request.name;
+    if (name === void 0) {
+      const base = path20.basename(cwd) || "terminal";
+      const taken = new Set(owned.map((session2) => session2.info().name));
+      name = base;
+      for (let n = 2; taken.has(name); n += 1) name = `${base} ${n}`;
+    }
+    const usedSeqs = new Set(owned.map((session2) => session2.seq));
+    let seq = 1;
+    while (usedSeqs.has(seq)) seq += 1;
+    const options = {
+      cwd,
+      ownerUserId: request.ownerUserId,
+      seq,
+      name,
+      resources: this.resources,
+      ...request.cols !== void 0 ? { cols: request.cols } : {},
+      ...request.rows !== void 0 ? { rows: request.rows } : {},
+      ...request.shell !== void 0 ? { shell: request.shell } : {}
+    };
+    let session;
+    try {
+      session = new TerminalSession(options);
+    } catch (err) {
+      const hint = spawnHelperHint();
+      throw new HttpError(
+        500,
+        "terminal_spawn_failed",
+        `Could not start a shell: ${err instanceof Error ? err.message : String(err)}` + (hint === null ? "" : ` (${hint})`)
+      );
+    }
+    this.track(session);
+    return session;
+  }
+  /**
+   * Takes a session into this manager AND into the runtime's resource registry. The
+   * registry is what makes a pty outlive a platform swap: it sits outside the reloadable
+   * tree, so the shell keeps running and the next instance claims it back (see
+   * hmr/resources.ts). The parked context carries only these ids.
+   */
+  track(session) {
+    this.sessions.set(session.id, session);
+    session.onExit(() => this.scheduleReap(session.id));
+    this.resources.register(resourceId(session.id), session, () => session.dispose());
+  }
+  /**
+   * Reclaims the sessions a previous instance parked. An id the registry no longer knows
+   * is simply dropped: its shell died with the process that owned it, and a manager
+   * holding a handle to nothing would only fail later, further from the cause.
+   */
+  adopt(ids) {
+    for (const id of ids) {
+      const session = this.resources.claim(resourceId(id));
+      if (session === void 0) continue;
+      this.sessions.set(session.id, session);
+      session.onExit(() => this.scheduleReap(session.id));
+    }
+  }
+  /** Handle ids for the parked context document — live sessions only. */
+  handleIds() {
+    return [...this.sessions.values()].filter((s) => s.alive).map((s) => s.id);
+  }
+  /** Looks up a session, enforcing ownership. Unknown and not-yours are both 404 — no probing. */
+  require(id, userId) {
+    const session = this.sessions.get(id);
+    if (!session || session.ownerUserId !== userId) {
+      throw new HttpError(404, "terminal_not_found", "Terminal does not exist or has been closed.");
+    }
+    return session;
+  }
+  get(id) {
+    return this.sessions.get(id);
+  }
+  list(userId) {
+    return [...this.sessions.values()].filter((session) => session.ownerUserId === userId).sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+  }
+  listInfo(userId) {
+    return this.list(userId).map((session) => session.info());
+  }
+  kill(id, userId) {
+    const session = this.require(id, userId);
+    session.kill();
+    this.scheduleReap(id, 2e3);
+  }
+  /** Drops the session once nothing can usefully be read from it any more. */
+  scheduleReap(id, delayMs = this.graceMs) {
+    const existing = this.reapTimers.get(id);
+    if (existing) clearTimeout(existing);
+    const timer = setTimeout(() => {
+      this.reapTimers.delete(id);
+      this.sessions.get(id)?.dispose();
+      this.sessions.delete(id);
+      this.resources.release(resourceId(id));
+    }, delayMs);
+    timer.unref?.();
+    this.reapTimers.set(id, timer);
+  }
+  /** Server shutdown: every pty is a child process and must not outlive us. */
+  disposeAll() {
+    for (const timer of this.reapTimers.values()) clearTimeout(timer);
+    this.reapTimers.clear();
+    for (const session of this.sessions.values()) session.dispose();
+    this.sessions.clear();
+  }
+};
+async function resolveCwd(input) {
+  const expanded = expandHomePath((input ?? "").trim() || "~");
+  if (!path20.isAbsolute(expanded)) {
+    throw new HttpError(400, "cwd_not_absolute", `Working directory must be absolute: ${expanded}`);
+  }
+  let real;
+  try {
+    real = await fsp.realpath(expanded);
+  } catch {
+    throw new HttpError(400, "cwd_not_found", `Directory does not exist: ${expanded}`);
+  }
+  const stat = await fsp.stat(real);
+  if (!stat.isDirectory()) {
+    throw new HttpError(400, "cwd_not_a_dir", `Not a directory: ${real}`);
+  }
+  return real;
+}
+function resourceId(sessionId) {
+  return `terminal:${sessionId}`;
+}
+
+// src/platform/terminal/routes.ts
+import { Hono as Hono25 } from "hono";
+
+// src/platform/hono-seam.ts
+var DECLINE_HEADER = "x-penguin-platform-decline";
+var DECLINE_TOKEN = crypto.randomUUID();
+function declined() {
+  return new Response(null, { status: 404, headers: { [DECLINE_HEADER]: DECLINE_TOKEN } });
+}
+function seamHttp(app2) {
+  return async (request) => {
+    const response = await app2.fetch(request);
+    return response.headers.get(DECLINE_HEADER) === DECLINE_TOKEN ? null : response;
+  };
+}
+
+// src/platform/terminal/routes.ts
+var KEY_TOKENS = {
+  Enter: "\r",
+  Tab: "	",
+  Escape: "\x1B",
+  Backspace: "\x7F",
+  Space: " ",
+  Up: "\x1B[A",
+  Down: "\x1B[B",
+  Right: "\x1B[C",
+  Left: "\x1B[D",
+  Home: "\x1B[H",
+  End: "\x1B[F",
+  PageUp: "\x1B[5~",
+  PageDown: "\x1B[6~",
+  Delete: "\x1B[3~"
+};
+function resolveKeys(keys, literal) {
+  if (literal) return keys;
+  if (keys in KEY_TOKENS) return KEY_TOKENS[keys];
+  const ctrl = /^C-([a-z@[\]\\^_])$/i.exec(keys);
+  if (ctrl) {
+    const ch = ctrl[1].toUpperCase();
+    return String.fromCharCode(ch.charCodeAt(0) & 31);
+  }
+  return keys;
+}
+function optionalInt(value, field) {
+  if (value === void 0 || value === null) return void 0;
+  if (!Number.isInteger(value)) throw badRequest(`${field} must be an integer.`);
+  return value;
+}
+function json(body, status = 200) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "content-type": "application/json; charset=UTF-8" }
+  });
+}
+function errorResponse(err) {
+  if (err instanceof HttpError) {
+    return json({ error: { code: err.code, message: err.message } }, err.status);
+  }
+  const message = err instanceof Error ? err.message : String(err);
+  return json({ error: { code: "internal", message } }, 500);
+}
+async function readBody(request) {
+  try {
+    return await request.json();
+  } catch {
+    return {};
+  }
+}
+function terminalHttp(manager, identity) {
+  const app2 = new Hono25();
+  app2.notFound(() => declined());
+  app2.onError((err) => errorResponse(err));
+  const gate = async (c, next) => {
+    const user = await identity(c.req.raw);
+    if (user === null) {
+      return json({ error: { code: "unauthorized", message: "Not signed in." } }, 401);
+    }
+    c.set("user", user);
+    await next();
+  };
+  app2.get("/api/terminals", gate, (c) => json({ terminals: manager.listInfo(c.var.user.userId) }));
+  app2.post(
+    "/api/terminals",
+    gate,
+    async (c) => json(await create2(c.req.raw, manager, c.var.user.userId), 201)
+  );
+  app2.get(
+    "/api/terminals/:id",
+    gate,
+    (c) => json(manager.require(c.req.param("id"), c.var.user.userId).info())
+  );
+  app2.delete("/api/terminals/:id", gate, (c) => {
+    manager.kill(c.req.param("id"), c.var.user.userId);
+    return new Response(null, { status: 204 });
+  });
+  app2.get("/api/terminals/:id/capture", gate, (c) => {
+    const session = manager.require(c.req.param("id"), c.var.user.userId);
+    const start = c.req.query("start");
+    const end = c.req.query("end");
+    return json(
+      session.capture({
+        ...start !== void 0 ? { start: Number.parseInt(start, 10) } : {},
+        ...end !== void 0 ? { end: Number.parseInt(end, 10) } : {}
+      })
+    );
+  });
+  app2.post("/api/terminals/:id/keys", gate, async (c) => {
+    const session = manager.require(c.req.param("id"), c.var.user.userId);
+    const body = await readBody(c.req.raw);
+    if (typeof body.keys !== "string") throw badRequest("keys must be a string.");
+    if (!session.alive) {
+      throw new HttpError(409, "terminal_exited", "This terminal's shell has exited.");
+    }
+    session.write(resolveKeys(body.keys, body.literal === true));
+    return json({ ok: true });
+  });
+  return seamHttp(app2);
+}
+async function create2(request, manager, ownerUserId) {
+  const body = await readBody(request);
+  const cwd = typeof body.cwd === "string" && body.cwd.trim() ? body.cwd.trim() : "~";
+  const name = typeof body.name === "string" ? body.name : void 0;
+  const shell = typeof body.shell === "string" && body.shell.trim() ? body.shell.trim() : void 0;
+  const session = await manager.create({
+    cwd,
+    ownerUserId,
+    ...name !== void 0 ? { name } : {},
+    ...shell !== void 0 ? { shell } : {},
+    ...optionalInt(body.cols, "cols") !== void 0 ? { cols: body.cols } : {},
+    ...optionalInt(body.rows, "rows") !== void 0 ? { rows: body.rows } : {}
+  });
+  return session.info();
+}
+
+// src/platform/terminal/stream.ts
+import { randomUUID as randomUUID5 } from "crypto";
+
+// src/platform/terminal/frames.ts
+var TerminalStreamOpcode = {
+  /** Server -> client: terminal output bytes. */
+  Output: 1,
+  /** Client -> server: keyboard/paste input bytes. */
+  Input: 2,
+  /** Client -> server: viewport size, JSON `{cols, rows, intent}`. */
+  Resize: 3,
+  /** Server -> client: full-screen restore stream (ANSI), sent once on attach. */
+  Restore: 5,
+  /** Server -> client: the pty exited, JSON `{exitCode, signal}`. */
+  Exit: 6
+};
+var OPCODES = new Set(Object.values(TerminalStreamOpcode));
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+function encodeTerminalFrame(input) {
+  const payload = typeof input.payload === "string" ? encoder.encode(input.payload) : input.payload ?? new Uint8Array(0);
+  const bytes = new Uint8Array(2 + payload.byteLength);
+  bytes[0] = input.opcode;
+  bytes[1] = (input.slot ?? 0) & 255;
+  bytes.set(payload, 2);
+  return bytes;
+}
+function decodeTerminalFrame(bytes) {
+  if (bytes.byteLength < 2) return null;
+  const opcode = bytes[0];
+  if (!OPCODES.has(opcode)) return null;
+  return {
+    opcode,
+    slot: bytes[1],
+    payload: bytes.subarray(2)
+  };
+}
+function framePayloadText(frame) {
+  return decoder.decode(frame.payload);
+}
+function parseResizePayload(frame) {
+  let parsed;
+  try {
+    parsed = JSON.parse(framePayloadText(frame));
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null) return null;
+  const { cols, rows, intent } = parsed;
+  if (!Number.isInteger(cols) || !Number.isInteger(rows)) return null;
+  if (cols < 1 || rows < 1) return null;
+  return {
+    cols: Math.min(cols, 1e3),
+    rows: Math.min(rows, 500),
+    intent: intent === "update" ? "update" : "claim"
+  };
+}
+
+// src/platform/terminal/output-coalescer.ts
+var DEFAULT_COALESCE_WINDOW_MS = 5;
+var TerminalOutputCoalescer = class {
+  constructor(flushFn, windowMs = DEFAULT_COALESCE_WINDOW_MS, now = () => Date.now()) {
+    this.flushFn = flushFn;
+    this.windowMs = windowMs;
+    this.now = now;
+  }
+  flushFn;
+  windowMs;
+  now;
+  pending = "";
+  timer = null;
+  lastFlushAt = 0;
+  push(data) {
+    if (data.length === 0) return;
+    this.pending += data;
+    if (this.timer !== null) return;
+    const elapsed = this.now() - this.lastFlushAt;
+    if (elapsed >= this.windowMs) {
+      this.flush();
+      return;
+    }
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      this.flush();
+    }, this.windowMs - elapsed);
+  }
+  /**
+   * Flushes anything buffered. Callers must invoke this before sending an out-of-band
+   * message (restore, exit) so ordering with the output stream is preserved.
+   */
+  flush() {
+    if (this.timer !== null) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    this.lastFlushAt = this.now();
+    if (this.pending.length === 0) return;
+    const data = this.pending;
+    this.pending = "";
+    this.flushFn(data);
+  }
+  dispose() {
+    if (this.timer !== null) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    this.pending = "";
+  }
+};
+
+// src/platform/terminal/stream.ts
+var BACKPRESSURE_HIGH_WATER = 1024 * 1024;
+var BACKPRESSURE_LOW_WATER = 64 * 1024;
+var BACKPRESSURE_POLL_MS = 250;
+function bindTerminalStream(ws, session, url, log) {
+  const connectionId = randomUUID5();
+  ws.binaryType = "nodebuffer";
+  const send = (bytes) => {
+    if (ws.readyState === ws.OPEN) ws.send(bytes);
+  };
+  let desynced = false;
+  let resyncTimer = null;
+  const stopResyncPoll = () => {
+    if (resyncTimer) clearInterval(resyncTimer);
+    resyncTimer = null;
+  };
+  const sendOutput = (data) => {
+    if (desynced) return;
+    send(encodeTerminalFrame({ opcode: TerminalStreamOpcode.Output, payload: data }));
+    if (ws.bufferedAmount <= BACKPRESSURE_HIGH_WATER) return;
+    desynced = true;
+    log(`[terminal] stream ${session.id}: viewer ${ws.bufferedAmount}B behind, pausing for resync`);
+    resyncTimer = setInterval(() => {
+      if (ws.readyState !== ws.OPEN) return stopResyncPoll();
+      if (ws.bufferedAmount > BACKPRESSURE_LOW_WATER) return;
+      stopResyncPoll();
+      desynced = false;
+      try {
+        send(
+          encodeTerminalFrame({
+            opcode: TerminalStreamOpcode.Restore,
+            payload: session.restoreStream()
+          })
+        );
+      } catch {
+      }
+    }, BACKPRESSURE_POLL_MS);
+  };
+  let restored = false;
+  let preRestore = "";
+  const coalescer = new TerminalOutputCoalescer(sendOutput);
+  const unsubscribeOutput = session.onOutput((data) => {
+    if (!restored) {
+      preRestore += data;
+      return;
+    }
+    coalescer.push(data);
+  });
+  const unsubscribeExit = session.onExit((info) => {
+    coalescer.flush();
+    send(
+      encodeTerminalFrame({
+        opcode: TerminalStreamOpcode.Exit,
+        payload: JSON.stringify({ exitCode: info.exitCode, signal: info.signal })
+      })
+    );
+  });
+  const cols = Number.parseInt(url.searchParams.get("cols") ?? "", 10);
+  const rows = Number.parseInt(url.searchParams.get("rows") ?? "", 10);
+  if (Number.isInteger(cols) && Number.isInteger(rows)) {
+    session.resize({ connectionId, cols, rows, intent: "claim" });
+  }
+  send(
+    encodeTerminalFrame({
+      opcode: TerminalStreamOpcode.Restore,
+      payload: session.restoreStream()
+    })
+  );
+  restored = true;
+  if (preRestore) {
+    coalescer.push(preRestore);
+    preRestore = "";
+  }
+  if (!session.alive && session.exit) {
+    send(
+      encodeTerminalFrame({
+        opcode: TerminalStreamOpcode.Exit,
+        payload: JSON.stringify({ exitCode: session.exit.exitCode, signal: session.exit.signal })
+      })
+    );
+  }
+  ws.on("message", (raw, isBinary) => {
+    if (!isBinary) return;
+    const frame = decodeTerminalFrame(new Uint8Array(raw.buffer, raw.byteOffset, raw.byteLength));
+    if (!frame) return;
+    switch (frame.opcode) {
+      case TerminalStreamOpcode.Input:
+        session.write(framePayloadText(frame));
+        break;
+      case TerminalStreamOpcode.Resize: {
+        const size = parseResizePayload(frame);
+        if (size) session.resize({ connectionId, ...size });
+        break;
+      }
+      default:
+        break;
+    }
+  });
+  const teardown = () => {
+    unsubscribeOutput();
+    unsubscribeExit();
+    stopResyncPoll();
+    coalescer.dispose();
+    session.releaseSize(connectionId);
+  };
+  ws.on("close", teardown);
+  ws.on("error", (err) => {
+    log(`[terminal] stream ${session.id} socket error: ${err.message}`);
+    teardown();
+  });
+}
+
+// src/platform/platform.ts
 var PlatformIface = defineIface({
   name: "platform",
   version: 1,
-  context: schema(type({ motd: "string" })),
-  methods: ["park", "info"]
+  context: schema(type({ motd: "string", "terminals?": "string[]" })),
+  methods: ["park", "info", "http", "terminals", "attachStream"]
 });
 var platformImpl = {
-  create(_ctx, context) {
+  create(ctx, context) {
+    const terminals = new TerminalManager(ctx.resources);
+    terminals.adopt(context.terminals ?? []);
+    const http = terminalHttp(terminals, identityFrom(ctx.resources));
     return {
-      park: () => ({ motd: context.motd }),
+      // Deliberately NOT disposing the terminals here (no ctx.effect): the shells are
+      // resources, and outliving a swap is the whole point. Process exit sweeps them
+      // through the registry's own disposers.
+      park: () => ({ motd: context.motd, terminals: terminals.handleIds() }),
       info: () => ({
         impl: "packaged",
         ifaceVersion: PlatformIface.version,
-        motd: context.motd
-      })
+        motd: context.motd,
+        terminals: terminals.handleIds().length
+      }),
+      http,
+      terminals: () => terminals,
+      attachStream: (ws, session, url, log) => bindTerminalStream(ws, session, url, log)
     };
   }
 };
@@ -11783,13 +13820,15 @@ var packagedPlatform = {
 };
 
 // src/hmr/host.ts
+var ASSETS_RESOURCE_ID = "runtime:assets-dir";
+var MATERIALIZED = ".materialized";
 var STORE_KEEP = 2;
 var HmrHost = class {
   constructor(root) {
     this.root = root;
-    this.hmrDir = path16.join(root, "hmr");
-    this.storeDir = path16.join(this.hmrDir, "store");
-    this.manifestPath = path16.join(this.hmrDir, "harness.json");
+    this.hmrDir = path21.join(root, "hmr");
+    this.storeDir = path21.join(this.hmrDir, "store");
+    this.manifestPath = path21.join(this.hmrDir, "harness.json");
   }
   root;
   resources = new HotResources();
@@ -11875,7 +13914,7 @@ var HmrHost = class {
   async restore() {
     let manifest;
     try {
-      manifest = JSON.parse(await fsp.readFile(this.manifestPath, "utf8"));
+      manifest = JSON.parse(await fsp2.readFile(this.manifestPath, "utf8"));
     } catch {
       return;
     }
@@ -11892,12 +13931,19 @@ var HmrHost = class {
       if (manifest.web === void 0) {
         throw new Error("harness.json has no `web` entry");
       }
-      const cliPath = path16.join(this.hmrDir, manifest.cli.bundle);
-      if (!fs21.existsSync(cliPath)) {
+      const cliPath = path21.join(this.hmrDir, manifest.cli.bundle);
+      if (!fs22.existsSync(cliPath)) {
         throw new Error(`cli bundle '${manifest.cli.bundle}' does not exist`);
       }
-      const bundle = await this.importBundleFile(path16.join(this.hmrDir, manifest.platform.bundle));
-      const gz = await fsp.readFile(path16.join(this.hmrDir, manifest.web.manifest));
+      if (manifest.assets !== void 0) {
+        const assetsDir = path21.join(this.hmrDir, manifest.assets.dir);
+        if (!fs22.existsSync(assetsDir)) {
+          throw new Error(`assets dir '${manifest.assets.dir}' does not exist`);
+        }
+        this.publishAssets(assetsDir);
+      }
+      const bundle = await this.importBundleFile(path21.join(this.hmrDir, manifest.platform.bundle));
+      const gz = await fsp2.readFile(path21.join(this.hmrDir, manifest.web.manifest));
       const webMem = filesMapFromGzip(gz);
       const instance = await boot(
         bundle.impl,
@@ -11936,13 +13982,23 @@ var HmrHost = class {
     const platformPath = await this.writeInlinePlatformBundle(target.platform);
     const bundle = await this.importBundleFile(platformPath);
     const source = target.source ?? null;
-    const result = await upgrade({
-      current: current2,
-      impl: bundle.impl,
-      iface: bundle.iface,
-      resources: this.resources
-    });
+    const previousAssets = this.resources.claim(ASSETS_RESOURCE_ID) ?? null;
+    const assetsDir = target.assets ? await this.materializeAssets(target.assets) : null;
+    if (assetsDir !== null) this.publishAssets(assetsDir);
+    let result;
+    try {
+      result = await upgrade({
+        current: current2,
+        impl: bundle.impl,
+        iface: bundle.iface,
+        resources: this.resources
+      });
+    } catch (err) {
+      this.publishAssets(previousAssets);
+      throw err;
+    }
     if (result.status === "blocked") {
+      this.publishAssets(previousAssets);
       return {
         status: "blocked",
         dropped: result.dropped,
@@ -11959,7 +14015,8 @@ var HmrHost = class {
       target.platform,
       target.cli,
       gz,
-      digest2.slice(0, 16)
+      digest2.slice(0, 16),
+      assetsDir
     );
     return {
       status: "ok",
@@ -11972,8 +14029,8 @@ var HmrHost = class {
   }
   /** Layer (a) core: import one JS file, cache-busted so re-imports load fresh code. */
   async importBundleFile(file) {
-    const resolved = path16.resolve(file);
-    if (!fs21.existsSync(resolved)) throw new Error(`bundle file '${file}' does not exist`);
+    const resolved = path21.resolve(file);
+    if (!fs22.existsSync(resolved)) throw new Error(`bundle file '${file}' does not exist`);
     const url = `${pathToFileURL(resolved).href}?v=${Date.now()}`;
     const mod = await import(url);
     if (mod.hotPlatform === void 0) {
@@ -11995,10 +14052,10 @@ var HmrHost = class {
    * store.
    */
   async writeInlinePlatformBundle(content) {
-    const dir = path16.join(this.hmrDir, "uploads");
-    await fsp.mkdir(dir, { recursive: true });
-    const file = path16.join(dir, `platform-${sha1(content).slice(0, 16)}.mjs`);
-    await fsp.writeFile(file, content, "utf8");
+    const dir = path21.join(this.hmrDir, "uploads");
+    await fsp2.mkdir(dir, { recursive: true });
+    const file = path21.join(dir, `platform-${sha1(content).slice(0, 16)}.mjs`);
+    await fsp2.writeFile(file, content, "utf8");
     return file;
   }
   // -- Web platform (the frontend package's built dist) ---------------------
@@ -12028,23 +14085,59 @@ var HmrHost = class {
    * (`persisted` in UpgradeOutcome) so a live swap that could not be written to disk
    * is visibly at risk of reverting on the next restart, rather than silently ok.
    */
-  async persistVersion(platformContent, cliContent, webGz, webSha) {
+  /**
+   * Unpacks a push's assets under store/assets/<sha>/, content-addressed like every other
+   * artifact so an unchanged set reuses its directory. Modes are restored from the push's
+   * `exec` list: an asset arrives as base64 with no mode of its own, and a helper binary
+   * without its exec bit is exactly the failure this whole path exists to avoid.
+   *
+   * An identical set is NOT re-written. That is a correctness requirement, not a saving:
+   * these assets are native modules, and on Windows the copies from the last push are
+   * mapped into this very process — reopening one for writing fails with EBUSY and takes
+   * the whole upgrade down with it. The directory name already proves the content
+   * matches; MATERIALIZED, written last, is what proves the directory is complete, so a
+   * push interrupted halfway is repaired rather than trusted.
+   */
+  async materializeAssets(assets) {
+    const sha = filesDigest(assets.files).slice(0, 16);
+    const dir = path21.join(this.storeDir, "assets", sha);
+    const marker = path21.join(dir, MATERIALIZED);
+    if (fs22.existsSync(marker)) return dir;
+    const exec = new Set(assets.exec ?? []);
+    for (const [rel, b64] of Object.entries(assets.files)) {
+      if (!isSafeRelPath(rel)) throw new Error(`unsafe path in assets manifest: ${rel}`);
+      const file = path21.join(dir, rel);
+      const content = Buffer.from(b64, "base64");
+      await fsp2.mkdir(path21.dirname(file), { recursive: true });
+      if (!await sameFileContent(file, content)) await fsp2.writeFile(file, content);
+      await fsp2.chmod(file, exec.has(rel) ? 493 : 420);
+    }
+    await fsp2.writeFile(marker, sha);
+    return dir;
+  }
+  /** Points the registry at this version's assets (or clears it when a push has none). */
+  publishAssets(dir) {
+    if (dir === null) this.resources.release(ASSETS_RESOURCE_ID);
+    else this.resources.register(ASSETS_RESOURCE_ID, dir);
+  }
+  async persistVersion(platformContent, cliContent, webGz, webSha, assetsDir) {
     try {
       const platformSha = sha1(platformContent).slice(0, 16);
-      const platformDir = path16.join(this.storeDir, "platform");
-      await fsp.mkdir(platformDir, { recursive: true });
-      await fsp.writeFile(path16.join(platformDir, `${platformSha}.mjs`), platformContent, "utf8");
+      const platformDir = path21.join(this.storeDir, "platform");
+      await fsp2.mkdir(platformDir, { recursive: true });
+      await fsp2.writeFile(path21.join(platformDir, `${platformSha}.mjs`), platformContent, "utf8");
       const cliSha = sha1(cliContent).slice(0, 16);
-      const cliDir = path16.join(this.storeDir, "cli");
-      await fsp.mkdir(cliDir, { recursive: true });
-      await fsp.writeFile(path16.join(cliDir, `${cliSha}.mjs`), cliContent, "utf8");
-      const webDir = path16.join(this.storeDir, "web");
-      await fsp.mkdir(webDir, { recursive: true });
-      await fsp.writeFile(path16.join(webDir, `${webSha}.webz`), webGz);
+      const cliDir = path21.join(this.storeDir, "cli");
+      await fsp2.mkdir(cliDir, { recursive: true });
+      await fsp2.writeFile(path21.join(cliDir, `${cliSha}.mjs`), cliContent, "utf8");
+      const webDir = path21.join(this.storeDir, "web");
+      await fsp2.mkdir(webDir, { recursive: true });
+      await fsp2.writeFile(path21.join(webDir, `${webSha}.webz`), webGz);
       await this.commitManifest(() => ({
         platform: { bundle: `store/platform/${platformSha}.mjs` },
         cli: { bundle: `store/cli/${cliSha}.mjs` },
-        web: { manifest: `store/web/${webSha}.webz` }
+        web: { manifest: `store/web/${webSha}.webz` },
+        ...assetsDir === null ? {} : { assets: { dir: path21.relative(this.hmrDir, assetsDir).split(path21.sep).join("/") } }
       }));
       return true;
     } catch (err) {
@@ -12054,11 +14147,11 @@ var HmrHost = class {
   }
   /** Writes and atomically replaces harness.json (the single commit point for a whole version). */
   async commitManifest(next) {
-    await fsp.mkdir(this.hmrDir, { recursive: true });
+    await fsp2.mkdir(this.hmrDir, { recursive: true });
     const manifest = next();
     const tmp = `${this.manifestPath}.${process.pid}.tmp`;
-    await fsp.writeFile(tmp, JSON.stringify(manifest, null, 2));
-    await fsp.rename(tmp, this.manifestPath);
+    await fsp2.writeFile(tmp, JSON.stringify(manifest, null, 2));
+    await fsp2.rename(tmp, this.manifestPath);
     await this.pruneStore(manifest);
   }
   /**
@@ -12072,7 +14165,7 @@ var HmrHost = class {
     const keepNewest = async (dir, keys, referenced, remove) => {
       let names;
       try {
-        names = await fsp.readdir(dir);
+        names = await fsp2.readdir(dir);
       } catch {
         return;
       }
@@ -12081,7 +14174,7 @@ var HmrHost = class {
         const key = keys(name);
         if (key === null) continue;
         try {
-          const mtime = (await fsp.stat(path16.join(dir, name))).mtimeMs;
+          const mtime = (await fsp2.stat(path21.join(dir, name))).mtimeMs;
           byKey.set(key, Math.max(byKey.get(key) ?? 0, mtime));
         } catch {
         }
@@ -12093,29 +14186,37 @@ var HmrHost = class {
         if (!kept.has(key)) await remove(key).catch(() => void 0);
       }
     };
-    const platformDir = path16.join(this.storeDir, "platform");
+    const platformDir = path21.join(this.storeDir, "platform");
     const platformBundleRef = manifest.platform?.bundle.match(/([0-9a-f]+)\.mjs$/)?.[1] ?? null;
     await keepNewest(
       platformDir,
       (name) => /^([0-9a-f]+)\.mjs$/.exec(name)?.[1] ?? null,
       platformBundleRef,
-      (sha) => fsp.rm(path16.join(platformDir, `${sha}.mjs`), { force: true })
+      (sha) => fsp2.rm(path21.join(platformDir, `${sha}.mjs`), { force: true })
     );
-    const cliDir = path16.join(this.storeDir, "cli");
+    const cliDir = path21.join(this.storeDir, "cli");
     const cliRef = manifest.cli?.bundle.match(/([0-9a-f]+)\.mjs$/)?.[1] ?? null;
     await keepNewest(
       cliDir,
       (name) => /^([0-9a-f]+)\.mjs$/.exec(name)?.[1] ?? null,
       cliRef,
-      (sha) => fsp.rm(path16.join(cliDir, `${sha}.mjs`), { force: true })
+      (sha) => fsp2.rm(path21.join(cliDir, `${sha}.mjs`), { force: true })
     );
-    const webDir = path16.join(this.storeDir, "web");
+    const webDir = path21.join(this.storeDir, "web");
     const webRef = manifest.web?.manifest.match(/([0-9a-f]+)\.webz$/)?.[1] ?? null;
     await keepNewest(
       webDir,
       (name) => /^([0-9a-f]+)\.webz$/.exec(name)?.[1] ?? null,
       webRef,
-      (sha) => fsp.rm(path16.join(webDir, `${sha}.webz`), { force: true })
+      (sha) => fsp2.rm(path21.join(webDir, `${sha}.webz`), { force: true })
+    );
+    const assetsRoot = path21.join(this.storeDir, "assets");
+    const assetsRef = manifest.assets?.dir.match(/([0-9a-f]+)$/)?.[1] ?? null;
+    await keepNewest(
+      assetsRoot,
+      (name) => /^[0-9a-f]+$/.test(name) ? name : null,
+      assetsRef,
+      (sha) => fsp2.rm(path21.join(assetsRoot, sha), { recursive: true, force: true })
     );
   }
   /** Process-exit sweep only; never part of an upgrade. */
@@ -12129,13 +14230,22 @@ function errMsg(err) {
   return err instanceof Error ? err.message : String(err);
 }
 function sha1(content) {
-  return crypto.createHash("sha1").update(content).digest("hex");
+  return crypto2.createHash("sha1").update(content).digest("hex");
 }
 function filesDigest(files) {
-  const hash = crypto.createHash("sha1");
+  const hash = crypto2.createHash("sha1");
   for (const rel of Object.keys(files).sort()) hash.update(rel).update("\0").update(files[rel]);
   return hash.digest("hex");
 }
+async function sameFileContent(file, content) {
+  try {
+    const stat = await fsp2.stat(file);
+    if (!stat.isFile() || stat.size !== content.length) return false;
+    return (await fsp2.readFile(file)).equals(content);
+  } catch {
+    return false;
+  }
+}
 function isSafeRelPath(rel) {
   if (rel === "" || rel.startsWith("/") || rel.includes("\\")) return false;
   return rel.split("/").every((seg) => seg !== "" && seg !== "." && seg !== "..");
@@ -12164,10 +14274,10 @@ function filesMapFromGzip(gz) {
 
 // src/hmr/routes.ts
 import zlib2 from "zlib";
-import { Hono as Hono24 } from "hono";
+import { Hono as Hono26 } from "hono";
 var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["127.0.0.1", "::1", "localhost"]);
 function hmrRoutes(deps2) {
-  const routes = new Hono24();
+  const routes = new Hono26();
   const hmr = deps2.hmr;
   const cookieAuth = authMiddleware(deps2.authService);
   routes.use("*", async (c, next) => {
@@ -12231,6 +14341,14 @@ function hmrRoutes(deps2) {
         platform: payload.platform,
         cli: payload.cli,
         web: payload.web.files,
+        // Optional: a push that needs no real files on disk (no native module, no helper
+        // binary) simply omits it, and older pushers keep working unchanged.
+        ...payload.assets?.files ? {
+          assets: {
+            files: payload.assets.files,
+            ...payload.assets.exec ? { exec: payload.assets.exec } : {}
+          }
+        } : {},
         ...payload.source ? { source: payload.source } : {}
       });
     } catch (err) {
@@ -12282,10 +14400,10 @@ function platformHttpSeam(hmr) {
 }
 
 // src/http/routes/preview.ts
-import { Hono as Hono25 } from "hono";
+import { Hono as Hono27 } from "hono";
 var DIRECTORY_INDEX = "index.html";
 function previewRoutes(deps2) {
-  const app2 = new Hono25();
+  const app2 = new Hono27();
   app2.get("/:token/*", async (c) => {
     const token = c.req.param("token");
     const payload = token ? deps2.previewTokens.verify(token) : null;
@@ -12378,7 +14496,22 @@ function buildAppDeps(config2, overrides = {}) {
   });
   const recorder = new UsageRecorder(usageRepo, overrides.now ?? (() => /* @__PURE__ */ new Date()));
   const errors = new ErrorRecorder(errorsRepo, overrides.now ?? (() => /* @__PURE__ */ new Date()));
-  const titles = overrides.titles ?? new TitleGenerator({ sessions: sessionsRepo, channels, recorder, errors, log });
+  const notifyProjectUsers = (projectId, event) => {
+    const ownerUserId = projectsRepo.findById(projectId)?.ownerUserId;
+    if (ownerUserId === void 0) return;
+    const audience = /* @__PURE__ */ new Set([ownerUserId, ...membersRepo.list(projectId).map((m) => m.userId)]);
+    for (const userId of audience) {
+      channels.peek(userChannelKey(userId))?.publish(event, "server_event");
+    }
+  };
+  const titles = overrides.titles ?? new TitleGenerator({
+    sessions: sessionsRepo,
+    channels,
+    recorder,
+    errors,
+    log,
+    notifyProjectUsers
+  });
   const manager = new SessionManager({
     sessions: sessionsRepo,
     channels,
@@ -12390,21 +14523,8 @@ function buildAppDeps(config2, overrides = {}) {
     log,
     goals: goalsRepo,
     // Run-state flips reach the whole login session, not just the tab watching that one
-    // conversation. Audience = the Project's owner plus its members, i.e. exactly who
-    // ProjectsRepo.listAccessible would grant the Project to — nobody learns that a Session
-    // they cannot open changed state.
-    //
-    // `peek`, deliberately not `get`: a user who has never opened an event stream has no
-    // channel, and conjuring one to buffer badge updates nobody is listening to is pure waste
-    // (their next connection fetches the list, which carries the same statuses anyway).
-    notifyProjectUsers: (projectId, event) => {
-      const ownerUserId = projectsRepo.findById(projectId)?.ownerUserId;
-      if (ownerUserId === void 0) return;
-      const audience = /* @__PURE__ */ new Set([ownerUserId, ...membersRepo.list(projectId).map((m) => m.userId)]);
-      for (const userId of audience) {
-        channels.peek(userChannelKey(userId))?.publish(event, "server_event");
-      }
-    },
+    // conversation (see the shared publisher above for the audience).
+    notifyProjectUsers,
     ...overrides.now ? { now: overrides.now } : {}
   });
   managerRef = manager;
@@ -12434,6 +14554,7 @@ function buildAppDeps(config2, overrides = {}) {
     onPasswordChanged,
     sessionTtlMs: config2.authSessionTtlMs,
     sessionRenewMs: config2.authSessionRenewMs,
+    ...overrides.passwordHashCost !== void 0 ? { passwordHashCost: overrides.passwordHashCost } : {},
     ...overrides.now ? { now: overrides.now } : {}
   });
   const adminService = new AdminService({
@@ -12442,6 +14563,7 @@ function buildAppDeps(config2, overrides = {}) {
     projects: projectsRepo,
     projectService,
     onPasswordChanged,
+    ...overrides.passwordHashCost !== void 0 ? { passwordHashCost: overrides.passwordHashCost } : {},
     ...overrides.now ? { now: overrides.now } : {}
   });
   const sessionService = new SessionService({
@@ -12467,6 +14589,12 @@ function buildAppDeps(config2, overrides = {}) {
     },
     ...overrides.now ? { now: () => overrides.now().getTime() } : {}
   });
+  const hmr = new HmrHost(config2.root);
+  hmr.resources.register(IDENTITY_RESOURCE_ID, async (request) => {
+    const token = readSessionCookie(request.headers.get("cookie"));
+    const authed = token === null ? null : authService.authenticateWithMeta(token);
+    return authed === null ? null : { userId: authed.user.userId };
+  });
   return {
     config: config2,
     db,
@@ -12498,12 +14626,12 @@ function buildAppDeps(config2, overrides = {}) {
     sessionSources,
     errors,
     desktop: config2.desktopToken !== null ? new DesktopService(config2.desktopToken) : null,
-    hmr: new HmrHost(config2.root),
+    hmr,
     log
   };
 }
 function createApp(deps2) {
-  const app2 = new Hono26();
+  const app2 = new Hono28();
   app2.onError((err, c) => {
     const projectId = attributedProjectId(c, deps2);
     deps2.errors.record({
@@ -12567,6 +14695,9 @@ function createApp(deps2) {
   const auth = authMiddleware(deps2.authService);
   app2.use("/api/*", auth);
   app2.route("/api/me", meRoutes(deps2));
+  if (deps2.desktop) {
+    app2.route("/api/desktop/update", desktopUpdateRoutes(deps2));
+  }
   app2.route("/api/version", versionRoutes(deps2));
   app2.route("/api/admin/users", adminUsersRoutes(deps2));
   app2.route("/api/admin/settings", adminSettingsRoutes(deps2));
@@ -12576,6 +14707,7 @@ function createApp(deps2) {
   app2.route("/api/projects/:projectId/members", membersRoutes(deps2));
   app2.route("/api/projects/:projectId/models", modelsRoutes(deps2));
   app2.route("/api/projects/:projectId/chat-defaults", chatDefaultsRoutes(deps2));
+  app2.route("/api/projects/:projectId/command-policy", commandPolicyRoutes(deps2));
   app2.route("/api/projects/:projectId/agents", agentsRoutes(deps2));
   app2.route("/api/projects/:projectId/dirs", dirsRoutes(deps2));
   app2.route("/api/projects/:projectId/agents/:agentId/config", agentConfigRoutes(deps2));
@@ -12634,53 +14766,63 @@ function registerStaticRoutes(app2, resolveSource) {
       if (content2 === void 0) {
         return c.json(errorBody("not_found", "Resource does not exist."), 404);
       }
-      const type3 = CONTENT_TYPES2[path17.extname(servedPath).toLowerCase()] ?? "application/octet-stream";
+      const type3 = CONTENT_TYPES2[path22.extname(servedPath).toLowerCase()] ?? "application/octet-stream";
       return new Response(new Uint8Array(content2), {
         status: 200,
         headers: { "Content-Type": type3 }
       });
     }
     const webDist = source.dir;
-    if (!fs22.existsSync(webDist)) {
+    if (!fs23.existsSync(webDist)) {
       return c.json(errorBody("not_found", "Resource does not exist."), 404);
     }
-    const resolved = path17.resolve(webDist, rel);
-    const base = path17.resolve(webDist);
-    const target = resolved === base || resolved.startsWith(base + path17.sep) ? resolved : path17.join(base, "index.html");
+    const resolved = path22.resolve(webDist, rel);
+    const base = path22.resolve(webDist);
+    const target = resolved === base || resolved.startsWith(base + path22.sep) ? resolved : path22.join(base, "index.html");
     let file = target;
     try {
-      const stat = await fsp2.stat(file);
-      if (stat.isDirectory()) file = path17.join(file, "index.html");
-      await fsp2.access(file);
+      const stat = await fsp3.stat(file);
+      if (stat.isDirectory()) file = path22.join(file, "index.html");
+      await fsp3.access(file);
     } catch {
-      file = path17.join(base, "index.html");
+      file = path22.join(base, "index.html");
     }
     let content;
     try {
-      content = await fsp2.readFile(file);
+      content = await fsp3.readFile(file);
     } catch {
       return c.json(errorBody("not_found", "Resource does not exist."), 404);
     }
-    const type2 = CONTENT_TYPES2[path17.extname(file).toLowerCase()] ?? "application/octet-stream";
+    const type2 = CONTENT_TYPES2[path22.extname(file).toLowerCase()] ?? "application/octet-stream";
     return new Response(new Uint8Array(content), {
       status: 200,
       headers: { "Content-Type": type2 }
     });
   });
 }
+function readSessionCookie(header) {
+  if (header === null) return null;
+  for (const part of header.split(";")) {
+    const eq = part.indexOf("=");
+    if (eq === -1) continue;
+    if (part.slice(0, eq).trim() !== SESSION_COOKIE) continue;
+    return decodeURIComponent(part.slice(eq + 1).trim());
+  }
+  return null;
+}
 
 // src/config.ts
-import { randomBytes as randomBytes5 } from "crypto";
-import fs23 from "fs";
-import path18 from "path";
+import { randomBytes as randomBytes6 } from "crypto";
+import fs24 from "fs";
+import path23 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 = path18.dirname(fileURLToPath(import.meta.url));
-  const bundled = path18.resolve(here, "..", "web-dist");
-  if (fs23.existsSync(bundled)) return bundled;
-  return path18.resolve(here, "..", "..", "web", "dist");
+  const here = path23.dirname(fileURLToPath(import.meta.url));
+  const bundled = path23.resolve(here, "..", "web-dist");
+  if (fs24.existsSync(bundled)) return bundled;
+  return path23.resolve(here, "..", "..", "web", "dist");
 }
 function normalizePreviewOrigin(raw) {
   if (!raw || raw.trim() === "") return null;
@@ -12710,14 +14852,14 @@ function resolveServerConfig(env = process.env) {
     root,
     host,
     port,
-    dbPath: env.PENGUIN_WEB_DB ?? path18.join(root, "web.db"),
+    dbPath: env.PENGUIN_WEB_DB ?? path23.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
     // mode without a pinned value seeds a FULLY random password rather than the
     // printable penguin-<4 digits>: desktop sign-in goes through the shell's token, so
     // the seed never needs to be read — and index.ts deliberately does not print it.
-    seedAdminPassword: env.PENGUIN_SEED_ADMIN_PASSWORD?.trim() || (desktopToken !== null ? randomBytes5(24).toString("base64url") : null),
+    seedAdminPassword: env.PENGUIN_SEED_ADMIN_PASSWORD?.trim() || (desktopToken !== null ? randomBytes6(24).toString("base64url") : null),
     authSessionTtlMs: 7 * DAY_MS,
     authSessionRenewMs: 6 * DAY_MS,
     desktopToken,
@@ -12726,6 +14868,108 @@ function resolveServerConfig(env = process.env) {
   };
 }
 
+// src/terminal/ws.ts
+import { WebSocketServer } from "ws";
+var STREAM_PATH = /^\/api\/terminals\/([^/]+)\/stream$/;
+var BACKPRESSURE_HIGH_WATER2 = 1024 * 1024;
+var BACKPRESSURE_LOW_WATER2 = 64 * 1024;
+function attachTerminalWebSocket(server2, deps2) {
+  const wss = new WebSocketServer({ noServer: true, perMessageDeflate: false });
+  server2.on("upgrade", (req, socket, head) => {
+    const url = new URL(req.url ?? "/", "http://localhost");
+    const match = STREAM_PATH.exec(url.pathname);
+    if (!match) return;
+    if (!isAllowedOrigin(req)) return refuse(socket, 403, "Forbidden");
+    const token = readCookie(req.headers.cookie, SESSION_COOKIE);
+    const authed = token ? deps2.authService.authenticateWithMeta(token) : null;
+    if (!authed) return refuse(socket, 401, "Unauthorized");
+    void deps2.hmr.ensure().then((platform) => {
+      const manager = platform.api.terminals?.();
+      const session = manager?.get(match[1]);
+      if (!session || session.ownerUserId !== authed.user.userId) {
+        return refuse(socket, 404, "Not Found");
+      }
+      wss.handleUpgrade(req, socket, head, (ws) => {
+        platform.api.attachStream?.(ws, session, url, deps2.log);
+      });
+    }).catch((err) => {
+      deps2.log(`[terminal] stream upgrade failed: ${err instanceof Error ? err.message : err}`);
+      refuse(socket, 500, "Internal Server Error");
+    });
+  });
+}
+function isAllowedOrigin(req) {
+  const origin = req.headers.origin;
+  if (!origin) return true;
+  let parsed;
+  try {
+    parsed = new URL(origin);
+  } catch {
+    return false;
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return false;
+  return parsed.host === (req.headers.host ?? "");
+}
+function readCookie(header, name) {
+  if (!header) return null;
+  for (const part of header.split(";")) {
+    const eq = part.indexOf("=");
+    if (eq === -1) continue;
+    if (part.slice(0, eq).trim() !== name) continue;
+    try {
+      return decodeURIComponent(part.slice(eq + 1).trim());
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function refuse(socket, status, text) {
+  socket.write(`HTTP/1.1 ${status} ${text}\r
+Connection: close\r
+\r
+`);
+  socket.destroy();
+}
+
+// src/services/desktop-update-port.ts
+var UPDATE_STATES = /* @__PURE__ */ new Set([
+  "idle",
+  "checking",
+  "up-to-date",
+  "downloading",
+  "downloaded",
+  "error",
+  "unsupported"
+]);
+function parseUpdaterStatusMessage(data) {
+  if (typeof data !== "object" || data === null) return null;
+  const msg = data;
+  if (msg.type !== "desktop-updater-status") return null;
+  const status = msg.status;
+  if (typeof status !== "object" || status === null) return null;
+  if (typeof status.appVersion !== "string") return null;
+  if (typeof status.state !== "string" || !UPDATE_STATES.has(status.state)) return null;
+  if (status.seq !== void 0 && typeof status.seq !== "number") return null;
+  return status;
+}
+function shellPortOf(proc) {
+  const port = proc.parentPort;
+  return port && typeof port.on === "function" && typeof port.postMessage === "function" ? port : null;
+}
+function wireShellUpdatePort(desktop, port) {
+  port.on("message", (e) => {
+    const status = parseUpdaterStatusMessage(e.data);
+    if (status !== null) desktop.setUpdateStatus(status);
+  });
+  desktop.onUpdateCommand((action) => {
+    port.postMessage({
+      type: "desktop-updater-command",
+      action
+    });
+  });
+}
+
 // src/index.ts
 loadDotenv({ quiet: true });
 installGlobalProxyDispatcher();
@@ -12764,12 +15008,17 @@ deps.goalsRepo.abortOrphanedActive();
 var appHost = loopbackHostRoles(config.host)?.app ?? config.host;
 var ipv6Loopback = null;
 function writePortFile(file, port) {
-  fs24.mkdirSync(path19.dirname(file), { recursive: true });
+  fs25.mkdirSync(path24.dirname(file), { recursive: true });
   const tmp = `${file}.${process.pid}.tmp`;
-  fs24.writeFileSync(tmp, `${port}
+  fs25.writeFileSync(tmp, `${port}
 `);
-  fs24.renameSync(tmp, file);
+  fs25.renameSync(tmp, file);
 }
+var terminalWebSocketDeps = {
+  hmr: deps.hmr,
+  authService: deps.authService,
+  log: (line) => console.log(line)
+};
 var server = serve({ fetch: app.fetch, hostname: config.host, port: config.port }, (info) => {
   console.log(`penguin-server started: http://${appHost}:${info.port}`);
   console.log(`Data root: ${config.root}`);
@@ -12789,13 +15038,15 @@ var server = serve({ fetch: app.fetch, hostname: config.host, port: config.port
         `[server] IPv6 loopback listener unavailable (${err.code ?? err.message}); previews via localhost may not resolve.`
       );
     });
+    attachTerminalWebSocket(ipv6Loopback, terminalWebSocketDeps);
   }
 });
+attachTerminalWebSocket(server, terminalWebSocketDeps);
 function cleanupInstanceFiles() {
   releaseServerLock(config.root);
   if (config.portFile !== null) {
     try {
-      fs24.rmSync(config.portFile, { force: true });
+      fs25.rmSync(config.portFile, { force: true });
     } catch {
     }
   }
@@ -12823,6 +15074,10 @@ async function shutdown(signal, exitCode = 0) {
 process.on("SIGINT", () => void shutdown("SIGINT"));
 process.on("SIGTERM", () => void shutdown("SIGTERM"));
 deps.desktop?.onShutdownRequest(() => void shutdown("desktop-shutdown"));
+if (deps.desktop !== null) {
+  const shellPort = shellPortOf(process);
+  if (shellPort !== null) wireShellUpdatePort(deps.desktop, shellPort);
+}
 process.on("uncaughtException", (err) => {
   console.error(`[server] Uncaught exception: ${err.stack ?? err.message}`);
   deps.errors.record({ source: "process", err, code: "uncaught_exception" });