@sealant/mend 0.35.1 → 0.36.0-next.628

package/dist/main.js

@@ -1,21 +1,36 @@
 #!/usr/bin/env node
 import {
+  AGENT_MEMORY_FILES,
+  AGENT_MEMORY_MAX_DATABASE_BYTES,
+  AGENT_MEMORY_MAX_FILE_BYTES,
+  AGENT_MEMORY_ROOTS,
+  CODEX_MEMORY_DATABASE,
   GATEWAY_STATUSES,
   HARNESS_COMMANDS,
+  HOST_USER_NAMESPACE_FILES,
   LIVE_STATUSES,
   MendRequestError,
+  PI_PROFILE_AGENT_PATH,
+  PI_PROFILE_LOCAL_PACKAGES,
+  PI_PROFILE_MAX_FILE_BYTES,
+  WORKTREE_REMOVAL_FORCE_HINT,
   agentIsLive,
+  agentMemoryNameOf,
   agentOutcome,
   agentStartingFacts,
   agentStartingLine,
   captureLineOf,
   claudeGrantFacts,
   createSseParser,
+  csiUKeysOf,
   cwdFacts,
+  firstPositional,
   gitAuthorIssue,
   gitCurrentBranch,
   gitOriginUrl,
   gitTopLevel,
+  hostUserNamespacesFix,
+  hostUserNamespacesOf,
   isDetachChunk,
   isPasteChunk,
   landingFactLine,
@@ -33,16 +48,275 @@ import {
   servicesHoldOf,
   sessionDisplayName,
   spoken,
-  trackBracketedPaste
-} from "./chunk-SMH65F6Z.js";
+  terminalReadOnlyLine,
+  trackBracketedPaste,
+  validatePiProfile,
+  validateSecretFilePath
+} from "./chunk-OTYH35OK.js";
 
 // src/main.ts
 import { spawn as spawn3, spawnSync as spawnSync6 } from "node:child_process";
-import * as fs17 from "node:fs";
+import * as fs20 from "node:fs";
 import { createRequire } from "node:module";
-import * as net4 from "node:net";
-import * as os11 from "node:os";
-import * as path18 from "node:path";
+import * as net5 from "node:net";
+import * as os13 from "node:os";
+import * as path21 from "node:path";
+
+// src/agent-memory.ts
+import { randomUUID } from "node:crypto";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import * as zlib from "node:zlib";
+var CLAUDE_ROOT = AGENT_MEMORY_ROOTS.find((root) => root.harness === "claude")?.root ?? "";
+var claudeHome = () => process.env["CLAUDE_CONFIG_DIR"] ?? path.join(os.homedir(), ".claude");
+var claudeMemoryDirFor = (repoRoot, home = claudeHome()) => {
+  const keys = [repoRoot.replace(/[^a-zA-Z0-9]/g, "-"), repoRoot.replace(/[/.]/g, "-")];
+  for (const key of new Set(keys)) {
+    const dir = path.join(home, "projects", key, "memory");
+    if (fs.existsSync(dir) && fs.statSync(dir).isDirectory()) return dir;
+  }
+  return null;
+};
+var scanClaudeMemory = (dir) => {
+  const files = [];
+  const notes = [];
+  const walk2 = (abs, rel) => {
+    for (const entry of fs.readdirSync(abs, { withFileTypes: true }).toSorted((a, b) => a.name < b.name ? -1 : 1)) {
+      const at = rel === "" ? entry.name : `${rel}/${entry.name}`;
+      const full = path.join(abs, entry.name);
+      if (entry.isDirectory()) {
+        walk2(full, at);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      const bytes = fs.readFileSync(full);
+      if (bytes.byteLength > AGENT_MEMORY_MAX_FILE_BYTES) {
+        notes.push(`${at}: over ${AGENT_MEMORY_MAX_FILE_BYTES / 1024} KB, left out`);
+        continue;
+      }
+      const text = bytes.includes(0) ? null : bytes.toString("utf8");
+      files.push(
+        text !== null && Buffer.from(text, "utf8").equals(bytes) ? { path: `${CLAUDE_ROOT}/${at}`, encoding: "utf8", contents: text } : {
+          path: `${CLAUDE_ROOT}/${at}`,
+          encoding: "base64",
+          contents: bytes.toString("base64")
+        }
+      );
+    }
+  };
+  walk2(dir, "");
+  return { dir, files, notes };
+};
+var machineIdFor = (configDir, create) => {
+  const file = path.join(configDir, "machine-id");
+  try {
+    const existing = fs.readFileSync(file, "utf8").trim();
+    if (existing !== "") return existing;
+  } catch {
+  }
+  if (!create) return null;
+  const id = randomUUID();
+  fs.mkdirSync(configDir, { recursive: true });
+  fs.writeFileSync(file, `${id}
+`, { mode: 384 });
+  return id;
+};
+var importSourceFor = (configDir, repoRoot, options) => {
+  const machine = machineIdFor(configDir, options.create);
+  if (machine === null) return null;
+  return {
+    id: `${machine}:${repoRoot}`.slice(0, 1024),
+    label: (options.hostname ?? os.hostname()).replace(/[^A-Za-z0-9._-]/g, "-").slice(0, 64) || "this machine"
+  };
+};
+var memoryDisplayName = (filePath) => {
+  const named = agentMemoryNameOf(filePath);
+  if (named === null) return filePath;
+  return named.harness === "claude" ? named.name : `${named.harness}:${named.name}`;
+};
+var lost = (n, whose) => `${n} of ${whose} line${n === 1 ? " is" : "s are"} not in the result: its copy kept as a version`;
+var ADDED_NAMED = 20;
+var importReportLines = (report) => {
+  const lines = [];
+  const row = (word, filePath, why) => lines.push(
+    `  ${word.padEnd(9)} ${memoryDisplayName(filePath)}${why === void 0 ? "" : ` \xB7 ${why}`}`
+  );
+  report.added.slice(0, ADDED_NAMED).forEach((p) => row("added", p));
+  if (report.added.length > ADDED_NAMED) {
+    lines.push(`  ${"added".padEnd(9)} and ${report.added.length - ADDED_NAMED} more`);
+  }
+  for (const p of report.updated ?? []) {
+    row("updated", p, "unchanged in Mend since this machine's last import");
+  }
+  for (const merge of report.merged ?? []) {
+    const missing = merge.missingLines ?? 0;
+    const storeMissing = merge.storeMissingLines ?? 0;
+    row(
+      "merged",
+      merge.path,
+      missing > 0 ? lost(missing, "this machine's") : storeMissing > 0 ? lost(storeMissing, "Mend's") : merge.against === "last-import" ? "both changed since this machine's last import, both sides' lines kept" : merge.against === "summaries" ? "both sides' summaries kept, the newer one per conversation" : "both sides' lines kept, no earlier import to compare against"
+    );
+  }
+  for (const p of report.keptStored ?? []) {
+    row("kept", p, "changed in Mend since this machine's last import, not here");
+  }
+  for (const p of report.removedInMend ?? []) {
+    row("not added", p, "removed in Mend since this machine's last import");
+  }
+  for (const p of report.conflicting) {
+    row(
+      "conflict",
+      p,
+      "both changed, not mergeable: Mend's kept, this machine's kept as a version"
+    );
+  }
+  for (const p of report.skipped ?? []) row("skipped", p, "outside the memory limits");
+  return lines;
+};
+var importReportCounts = (report) => [
+  [report.added.length, "added"],
+  [report.unchanged.length, "unchanged"],
+  [report.updated?.length ?? 0, "updated"],
+  [report.merged?.length ?? 0, "merged"],
+  [report.keptStored?.length ?? 0, "kept as Mend has it"],
+  [report.removedInMend?.length ?? 0, "not added again"],
+  [report.conflicting.length, report.conflicting.length === 1 ? "conflict" : "conflicts"],
+  [report.skipped?.length ?? 0, "skipped"]
+].filter(([count]) => count !== 0).map(([count, word]) => `${count} ${word}`).join(" \xB7 ") || "nothing to import";
+var CODEX_THREADS_ROOT = AGENT_MEMORY_ROOTS.find((root) => root.root.endsWith("codex-threads"))?.root ?? ".mend/codex-threads";
+var firstLineOf = async (file) => {
+  const plain = fs.existsSync(file) ? file : null;
+  const compressed = plain === null && fs.existsSync(`${file}.zst`) ? `${file}.zst` : null;
+  if (plain === null && compressed === null) return null;
+  const source = fs.createReadStream(plain ?? compressed ?? file);
+  const stream = compressed === null ? source : source.pipe(zlib.createZstdDecompress());
+  let text = "";
+  try {
+    for await (const chunk of stream) {
+      text += Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk);
+      const end = text.indexOf("\n");
+      if (end !== -1) return text.slice(0, end);
+      if (text.length > 1024 * 1024) return null;
+    }
+    return null;
+  } catch {
+    return null;
+  } finally {
+    source.destroy();
+  }
+};
+var codexHome = () => process.env["CODEX_HOME"] ?? path.join(os.homedir(), ".codex");
+var codexStateDatabase = (home) => {
+  const names = fs.existsSync(home) ? fs.readdirSync(home).filter((name) => /^state_\d+\.sqlite$/.test(name)) : [];
+  const newest = names.toSorted(
+    (a, b) => Number(/\d+/.exec(b)?.[0] ?? 0) - Number(/\d+/.exec(a)?.[0] ?? 0)
+  )[0];
+  return newest === void 0 ? null : path.join(home, newest);
+};
+var scanCodexMemory = async (repoRoot, home = codexHome()) => {
+  const memories = path.join(home, "memories_1.sqlite");
+  const state = codexStateDatabase(home);
+  if (!fs.existsSync(memories) || state === null) {
+    return { home, files: [], summaries: 0, notes: [] };
+  }
+  const threads = new DatabaseSync(state, { readOnly: true });
+  const inRepo = (() => {
+    try {
+      return new Map(
+        threads.prepare(
+          threads.prepare("select name from pragma_table_info('threads') where name = 'memory_mode'").get() === void 0 ? "select id, cwd, rollout_path from threads" : "select id, cwd, rollout_path from threads where memory_mode = 'enabled'"
+        ).all().flatMap((row) => {
+          const cwd = row["cwd"];
+          const id = row["id"];
+          const rollout = row["rollout_path"];
+          return typeof id === "string" && typeof cwd === "string" && (cwd === repoRoot || cwd.startsWith(`${repoRoot}/`)) ? [[id, typeof rollout === "string" ? rollout : null]] : [];
+        })
+      );
+    } finally {
+      threads.close();
+    }
+  })();
+  const ids = [...inRepo.keys()];
+  if (ids.length === 0) return { home, files: [], summaries: 0, notes: [] };
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "mend-codex-import-"));
+  try {
+    const out = path.join(dir, "memories_1.sqlite");
+    const target = new DatabaseSync(out);
+    let summaries = 0;
+    try {
+      target.exec(`attach database '${memories.replaceAll("'", "''")}' as source`);
+      const schema = target.prepare(
+        "select type, name, sql from source.sqlite_master where sql is not null and name not like 'sqlite_%' order by type = 'index', name"
+      ).all();
+      for (const row of schema) {
+        if (typeof row["sql"] === "string") target.exec(row["sql"]);
+      }
+      target.exec("insert into main._sqlx_migrations select * from source._sqlx_migrations");
+      try {
+        target.exec(
+          "insert into main.consolidation_progress select * from source.consolidation_progress"
+        );
+      } catch {
+      }
+      const insert = target.prepare(
+        "insert into main.stage1_outputs select * from source.stage1_outputs where thread_id = ?"
+      );
+      for (const id of ids) summaries += Number(insert.run(id).changes);
+      target.exec(
+        "update main.stage1_outputs set selected_for_phase2 = 0, selected_for_phase2_source_updated_at = null"
+      );
+      target.exec("detach database source");
+    } finally {
+      target.close();
+    }
+    if (summaries === 0) return { home, files: [], summaries: 0, notes: [] };
+    const summarisedIds = (() => {
+      const copy = new DatabaseSync(out, { readOnly: true });
+      try {
+        return copy.prepare("select thread_id from stage1_outputs").all().flatMap((row) => typeof row["thread_id"] === "string" ? [row["thread_id"]] : []);
+      } finally {
+        copy.close();
+      }
+    })();
+    const threadLines = [];
+    for (const id of summarisedIds) {
+      const rollout = inRepo.get(id) ?? null;
+      const head = rollout === null ? null : await firstLineOf(rollout);
+      if (head !== null) {
+        threadLines.push({
+          path: `${CODEX_THREADS_ROOT}/${id}.jsonl`,
+          encoding: "utf8",
+          contents: `${head}
+`
+        });
+      }
+    }
+    const bytes = fs.readFileSync(out);
+    if (bytes.byteLength > AGENT_MEMORY_MAX_DATABASE_BYTES) {
+      return {
+        home,
+        files: [],
+        summaries,
+        notes: [
+          `codex: ${summaries} summaries, over ${AGENT_MEMORY_MAX_DATABASE_BYTES / 1024 / 1024} MB, left out`
+        ]
+      };
+    }
+    return {
+      home,
+      files: [
+        { path: CODEX_MEMORY_DATABASE, encoding: "base64", contents: bytes.toString("base64") },
+        ...threadLines
+      ],
+      summaries,
+      notes: []
+    };
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+};
 
 // src/agent-share.ts
 import * as net from "node:net";
@@ -50,7 +324,7 @@ import { setTimeout as delay } from "node:timers/promises";
 var retryDelayMs = (attempt2) => Math.min(3e4, 1e3 * 2 ** Math.min(Math.max(attempt2 - 1, 0), 5));
 var SSH_AGENTC_REQUEST_IDENTITIES = 11;
 var SSH_AGENTC_SIGN_REQUEST = 13;
-var askLocalAgent = (agentSock, payload) => new Promise((resolve7, reject) => {
+var askLocalAgent = (agentSock, payload) => new Promise((resolve8, reject) => {
   const connection = net.connect(agentSock, () => {
     connection.write(payload);
   });
@@ -64,7 +338,7 @@ var askLocalAgent = (agentSock, payload) => new Promise((resolve7, reject) => {
     if (pending.length >= 4 && pending.length >= 4 + pending.readUInt32BE(0)) {
       clearTimeout(timer);
       connection.end();
-      resolve7(pending.subarray(0, 4 + pending.readUInt32BE(0)));
+      resolve8(pending.subarray(0, 4 + pending.readUInt32BE(0)));
     }
   });
   connection.on("error", (error) => {
@@ -94,12 +368,12 @@ var shareAgent = async (options) => {
     const ws = new WebSocket(target);
     const onAbort = () => ws.close();
     signal.addEventListener("abort", onAbort, { once: true });
-    const closed = new Promise((resolve7) => {
-      ws.addEventListener("close", () => resolve7(), { once: true });
+    const closed = new Promise((resolve8) => {
+      ws.addEventListener("close", () => resolve8(), { once: true });
     });
-    const opened = await new Promise((resolve7) => {
-      ws.addEventListener("open", () => resolve7(true), { once: true });
-      ws.addEventListener("error", () => resolve7(false), { once: true });
+    const opened = await new Promise((resolve8) => {
+      ws.addEventListener("open", () => resolve8(true), { once: true });
+      ws.addEventListener("error", () => resolve8(false), { once: true });
     });
     if (opened) {
       attempt2 = 0;
@@ -216,25 +490,34 @@ var firstOutputGate = (options) => {
   };
 };
 
+// src/attach-watch.ts
+var watchesTerminal = (detail) => detail?.control?.terminalInput === false;
+var ownerNameOf = (ownerUserId, members) => members.find((member) => member.userId === ownerUserId)?.name ?? "its owner";
+var watchNotice = (ownerName) => terminalReadOnlyLine(ownerName);
+var isInterruptChunk = (data) => data.includes(3) || csiUKeysOf(data).some(
+  (key) => key.code === 99 && (key.mods & ~1) === 4 && (key.event === 1 || key.event === 2)
+);
+var watchKey = (data, detachKeyEnabled2) => detachKeyEnabled2 && isDetachChunk(data) || isInterruptChunk(data) ? "detach" : null;
+
 // src/claude-grant.ts
 import { spawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-var claudeGrantDir = (home) => path.join(home, "claude-grant");
+import * as fs2 from "node:fs";
+import * as os2 from "node:os";
+import * as path2 from "node:path";
+var claudeGrantDir = (home) => path2.join(home, "claude-grant");
 var forgetGrant = (configDir, platform = process.platform) => {
-  fs.rmSync(configDir, { recursive: true, force: true });
+  fs2.rmSync(configDir, { recursive: true, force: true });
   if (platform !== "darwin") return;
   spawnSync(
     "security",
-    ["delete-generic-password", "-a", os.userInfo().username, "-s", keychainService(configDir)],
+    ["delete-generic-password", "-a", os2.userInfo().username, "-s", keychainService(configDir)],
     { stdio: "ignore", timeout: 6e4 }
   );
 };
 var personalClaudeDir = (environment = process.env) => {
   const configured = environment["CLAUDE_CONFIG_DIR"];
-  return configured === void 0 || configured === "" ? path.join(os.homedir(), ".claude") : configured;
+  return configured === void 0 || configured === "" ? path2.join(os2.homedir(), ".claude") : configured;
 };
 var keychainService = (configDir) => {
   const suffix = createHash("sha256").update(configDir).digest("hex").slice(0, 8);
@@ -256,10 +539,10 @@ var grantStatus = (cli, configDir) => {
   try {
     const parsed = JSON.parse(result.stdout.slice(start));
     if (typeof parsed !== "object" || parsed === null) return null;
-    const record = { ...parsed };
-    const text = (key) => typeof record[key] === "string" ? record[key] : null;
+    const record2 = { ...parsed };
+    const text = (key) => typeof record2[key] === "string" ? record2[key] : null;
     return {
-      loggedIn: record["loggedIn"] === true,
+      loggedIn: record2["loggedIn"] === true,
       authMethod: text("authMethod"),
       configDirectory: text("configDirectory"),
       email: text("email"),
@@ -270,7 +553,7 @@ var grantStatus = (cli, configDir) => {
   }
 };
 var runClaudeLogin = (cli, configDir) => {
-  fs.mkdirSync(configDir, { recursive: true, mode: 448 });
+  fs2.mkdirSync(configDir, { recursive: true, mode: 448 });
   const result = spawnSync(cli.bin, ["auth", "login", "--claudeai"], {
     stdio: "inherit",
     env: { ...cli.env, CLAUDE_CONFIG_DIR: configDir }
@@ -278,16 +561,16 @@ var runClaudeLogin = (cli, configDir) => {
   return result.error === void 0 && result.status === 0;
 };
 var readGrant = (configDir, platform = process.platform) => {
-  const file = path.join(configDir, ".credentials.json");
-  if (fs.existsSync(file)) {
-    const secret2 = fs.readFileSync(file, "utf8").trim();
+  const file = path2.join(configDir, ".credentials.json");
+  if (fs2.existsSync(file)) {
+    const secret2 = fs2.readFileSync(file, "utf8").trim();
     if (secret2 !== "") return { kind: "file", secret: secret2, path: file };
   }
   if (platform !== "darwin") return { kind: "missing", triedPath: file, triedService: null };
   const service = keychainService(configDir);
   const result = spawnSync(
     "security",
-    ["find-generic-password", "-a", os.userInfo().username, "-w", "-s", service],
+    ["find-generic-password", "-a", os2.userInfo().username, "-w", "-s", service],
     { encoding: "utf8", timeout: 6e4 }
   );
   const secret = typeof result.stdout === "string" ? result.stdout.trim() : "";
@@ -308,13 +591,13 @@ var parsePngfHex = (output) => {
   return Buffer.from(match[1], "hex");
 };
 var MAX_BYTES = 32 * 1024 * 1024;
-var run = (command, args) => new Promise((resolve7) => {
+var run = (command, args) => new Promise((resolve8) => {
   execFile(
     command,
     [...args],
     { encoding: "buffer", maxBuffer: MAX_BYTES, timeout: 3e3 },
     (error, stdout) => {
-      resolve7(error === null ? stdout : null);
+      resolve8(error === null ? stdout : null);
     }
   );
 });
@@ -353,17 +636,17 @@ var readClipboardImage = async (platform = process.platform, env = process.env)
 
 // src/codex-grant.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
-import * as fs3 from "node:fs";
-import * as os2 from "node:os";
-import * as path3 from "node:path";
+import * as fs4 from "node:fs";
+import * as os3 from "node:os";
+import * as path4 from "node:path";
 
 // src/login-dir.ts
-import * as fs2 from "node:fs";
-import * as path2 from "node:path";
+import * as fs3 from "node:fs";
+import * as path3 from "node:path";
 var throwawayLoginDir = (parent, prefix) => {
-  fs2.mkdirSync(parent, { recursive: true, mode: 448 });
-  const dir = fs2.mkdtempSync(path2.join(parent, prefix));
-  fs2.chmodSync(dir, 448);
+  fs3.mkdirSync(parent, { recursive: true, mode: 448 });
+  const dir = fs3.mkdtempSync(path3.join(parent, prefix));
+  fs3.chmodSync(dir, 448);
   return dir;
 };
 
@@ -374,12 +657,12 @@ var codexCli = (environment = process.env) => ({
 });
 var personalCodexHome = (environment = process.env) => {
   const configured = environment["CODEX_HOME"];
-  return configured === void 0 || configured === "" ? path3.join(os2.homedir(), ".codex") : configured;
+  return configured === void 0 || configured === "" ? path4.join(os3.homedir(), ".codex") : configured;
 };
-var runCodexDeviceLogin = (cli, codexHome) => {
+var runCodexDeviceLogin = (cli, codexHome2) => {
   const result = spawnSync2(cli.bin, ["login", "--device-auth"], {
     stdio: "inherit",
-    env: { ...cli.env, CODEX_HOME: codexHome }
+    env: { ...cli.env, CODEX_HOME: codexHome2 }
   });
   return result.error === void 0 && result.status === 0;
 };
@@ -407,11 +690,11 @@ var codexGrant = (input) => {
     if (!runCodexDeviceLogin(input.cli, home)) {
       return { kind: "failed", reason: "codex: the login did not complete" };
     }
-    const file = path3.join(home, "auth.json");
-    if (!fs3.existsSync(file)) {
+    const file = path4.join(home, "auth.json");
+    if (!fs4.existsSync(file)) {
       return { kind: "failed", reason: `codex: logged in, but no auth.json appeared in ${home}` };
     }
-    const secret = fs3.readFileSync(file, "utf8").trim();
+    const secret = fs4.readFileSync(file, "utf8").trim();
     if (refreshTokenOf(secret) === null) {
       return {
         kind: "failed",
@@ -426,19 +709,259 @@ var codexGrant = (input) => {
     }
     return { kind: "grant", secret };
   } finally {
-    fs3.rmSync(home, { recursive: true, force: true });
+    fs4.rmSync(home, { recursive: true, force: true });
   }
 };
 
 // src/doctor-bundle-collectors.ts
-import * as fs5 from "node:fs";
-import * as os3 from "node:os";
-import * as path5 from "node:path";
+import * as fs6 from "node:fs";
+import * as os4 from "node:os";
+import * as path6 from "node:path";
+
+// src/server-edge.ts
+import * as net2 from "node:net";
+
+// src/server-edge-files.ts
+var EDGE_COMPOSE_OVERLAY = [
+  "# Opt-in overlay: a TLS edge in front of a packaged Mend install",
+  '# (docs/adr/0004-access-without-a-private-network.md, "The access model").',
+  "#",
+  "# `mend server setup --edge <host>` writes this file and the Caddyfile into the install's",
+  "# generation beside compose.yaml, with MEND_EDGE_HOST in server.env, and every start, restart and",
+  "# upgrade of that install runs the two files together. The CLI carries a copy of both",
+  "# (apps/cli/src/server-edge.ts); its tests hold the copy to this file.",
+  "#",
+  "# For a Compose install you run yourself, from compose.v2.yaml and your own .env:",
+  "#",
+  "#   docker compose -f compose.v2.yaml -f compose.edge.yaml up -d",
+  "#",
+  "# In .env, beside what compose.v2.yaml needs:",
+  "#   MEND_EDGE_HOST=mend.example.com        the name the certificate is for; its DNS points here",
+  "#   APP_URL=https://mend.example.com       exactly https://<MEND_EDGE_HOST>",
+  "#   MEND_EXPOSURE=public                   or private, when admission to this host is yours to control",
+  "#",
+  "# Checked: the merged files render, and the Caddyfile validates. Not checked: a certificate issued",
+  "# and a browser session through it, end to end.",
+  "#",
+  "# The edge publishes 80 and 443. Mend's own port stays on loopback (MEND_BIND_HOST), so the only",
+  "# way in from outside is through TLS. Ports 80/443 on a public address mean a public certificate,",
+  "# and the hostname appears in certificate transparency logs.",
+  "#",
+  "# This does not make an instance fit to expose. `mend operator exposure` reports what Mend observes",
+  "# and what is still open; the last items are yours to verify.",
+  "services:",
+  "  edge:",
+  "    image: caddy:2.10-alpine",
+  "    restart: unless-stopped",
+  "    depends_on:",
+  "      mend:",
+  "        condition: service_started",
+  "    ports:",
+  '      - "${MEND_EDGE_BIND_HOST:-0.0.0.0}:80:80"',
+  '      - "${MEND_EDGE_BIND_HOST:-0.0.0.0}:443:443"',
+  '      - "${MEND_EDGE_BIND_HOST:-0.0.0.0}:443:443/udp"',
+  "    environment:",
+  "      MEND_EDGE_HOST:",
+  '        "${MEND_EDGE_HOST:?set MEND_EDGE_HOST in .env, the name the certificate is for}"',
+  "    volumes:",
+  "      - ./Caddyfile:/etc/caddy/Caddyfile:ro",
+  "      - mend-edge-data:/data",
+  "      - mend-edge-config:/config",
+  "    # The edge talks to Mend and to nothing else: it is not on the network that holds Postgres,",
+  "    # the bucket and the workspaces.",
+  "    networks: [edge]",
+  "    cap_drop: [ALL]",
+  "    cap_add: [NET_BIND_SERVICE]",
+  '    security_opt: ["no-new-privileges:true"]',
+  "",
+  "  mend:",
+  "    networks: [default, edge]",
+  "    environment:",
+  "      # The one hop whose X-Forwarded-For entries Mend believes: the edge's network, fixed below.",
+  "      # Both follow MEND_EDGE_SUBNET, so moving the subnet cannot leave the old range trusted.",
+  "      MEND_TRUSTED_PROXIES: ${MEND_TRUSTED_PROXIES:-${MEND_EDGE_SUBNET:-192.168.250.0/28}}",
+  "      MEND_EXPOSURE: ${MEND_EXPOSURE:-private}",
+  "      # Executors reach the session channel over plain http on this Compose network, which never",
+  "      # leaves the host. That is this overlay's statement, reported by Mend as declared.",
+  "      MEND_EXECUTOR_NETWORK: ${MEND_EXECUTOR_NETWORK:-private}",
+  "      MEND_URL_BEARERS: ${MEND_URL_BEARERS:-accept}",
+  "      MEND_EXPOSURE_REASSESSED: ${MEND_EXPOSURE_REASSESSED:-}",
+  "      MEND_EXPOSURE_DECLARED: ${MEND_EXPOSURE_DECLARED:-}",
+  "",
+  "networks:",
+  "  edge:",
+  "    ipam:",
+  "      config:",
+  "        # Sixteen addresses for one edge and one Mend. Set MEND_EDGE_SUBNET when this range is",
+  "        # already routed where the host lives (no private range is free everywhere).",
+  "        - subnet: ${MEND_EDGE_SUBNET:-192.168.250.0/28}",
+  "",
+  "volumes:",
+  "  mend-edge-data:",
+  "  mend-edge-config:"
+].join("\n") + "\n";
+var EDGE_CADDYFILE = [
+  "# The edge for a packaged Mend install (docs/adr/0004-access-without-a-private-network.md).",
+  "# TLS ends here: Caddy obtains and renews a certificate for MEND_EDGE_HOST and redirects port 80.",
+  "# Everything goes to Mend's web tier, which proxies /api, the event stream and every WebSocket on",
+  "# this one origin. Nothing else is routed: not the API, not Sealant, not the session channel, not",
+  "# the bucket.",
+  "{$MEND_EDGE_HOST} {",
+  "	encode zstd gzip",
+  "",
+  "	# Mend's web tier deletes inbound Forwarded, X-Forwarded-Host and X-Forwarded-Proto and appends",
+  "	# the address it saw to X-Forwarded-For. Caddy sets X-Forwarded-For to the client it accepted;",
+  "	# it does not trust one a client sent, since no trusted_proxies are configured above it.",
+  "	reverse_proxy mend:3105 {",
+  "		# Terminals and the event stream are long-lived: never buffer, never time them out.",
+  "		flush_interval -1",
+  "	}",
+  "",
+  "	log {",
+  "		output stdout",
+  "		# The terminal, tunnel and key bridge sockets and the phone's embed carry a single-use",
+  "		# ticket in the query, and pairing carries a code. A log holds none of them. Caddy already",
+  "		# redacts Authorization, Cookie and Set-Cookie.",
+  "		format filter {",
+  "			wrap json",
+  "			fields {",
+  "				request>uri query {",
+  "					replace ticket REDACTED",
+  "					replace token REDACTED",
+  "					replace code REDACTED",
+  "				}",
+  "				request>headers>Referer delete",
+  "			}",
+  "		}",
+  "	}",
+  "}"
+].join("\n") + "\n";
+
+// src/server-edge.ts
+var EXPOSURES = ["loopback", "private", "public"];
+var TENANCIES = ["single", "multi"];
+var isExposure = (value) => EXPOSURES.some((exposure) => exposure === value);
+var isTenancy = (value) => TENANCIES.some((tenancy) => tenancy === value);
+var EDGE_IMAGE = "caddy:2.10-alpine";
+var EDGE_COMPOSE_FILE = "compose.edge.yaml";
+var POSTURE_COMPOSE_FILE = "compose.posture.yaml";
+var parseEdgeHost = (value) => {
+  const host = value.trim().toLowerCase().replace(/\.$/, "");
+  const labels = host.split(".");
+  const label = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
+  if (host.length === 0 || host.length > 253 || labels.length < 2 || !labels.every((part) => label.test(part)) || net2.isIP(host) !== 0) {
+    return null;
+  }
+  return host;
+};
+var postureEnvironment = (posture) => {
+  const gate = posture.tenancy === "multi" || posture.exposure === "public";
+  return [
+    ...posture.exposure === void 0 ? [] : [["MEND_EXPOSURE", posture.exposure]],
+    ...posture.tenancy === void 0 ? [] : [["MEND_TENANCY", posture.tenancy]],
+    ...gate ? [["MEND_SOURCE_POLICY", "tenant"], ["MEND_CAPTURE_REQUIRE_SIZES", "true"]] : [],
+    ...posture.exposure === "public" ? [["MEND_URL_BEARERS", "refuse"]] : []
+  ];
+};
+var postureEnvLines = (posture) => [
+  ...posture.edgeHost === void 0 ? [] : [`MEND_EDGE_HOST=${posture.edgeHost}`],
+  ...postureEnvironment(posture).map(([key, value]) => `${key}=${value}`)
+];
+var renderPostureOverlay = (posture) => {
+  const entries = postureEnvironment(posture);
+  if (entries.length === 0) return void 0;
+  return [
+    "# Written by mend server setup: the posture this install declares, read from server.env",
+    "# (docs/adr/0003-organizations-and-tenancy.md, docs/adr/0004-access-without-a-private-network.md).",
+    "# MEND_EXPOSURE and MEND_TENANCY are the operator's statements. With multi tenancy or a public",
+    "# exposure, the multi mode gate's configuration items follow: Mend's own git keeps to the tenant",
+    "# source policy and every capture upload is signed for its size. MEND_GIT_TRANSPORT_BIND_ORIGIN",
+    "# and MEND_SERVICE_HOSTS are not set, which is what the gate asks of them.",
+    "services:",
+    "  mend:",
+    "    environment:",
+    ...entries.map(([key]) => `      ${key}: \${${key}:?set ${key} in server.env}`),
+    ""
+  ].join("\n");
+};
+var composeOverlays = (posture) => [
+  ...posture.edgeHost === void 0 ? [] : [EDGE_COMPOSE_FILE],
+  ...renderPostureOverlay(posture) === void 0 ? [] : [POSTURE_COMPOSE_FILE]
+];
+var record = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? new Map(Object.entries(value)) : null;
+var healthPosture = (body) => {
+  const fields = record(body);
+  const tenancy = fields?.get("tenancy");
+  const gate = record(fields?.get("tenancyGate"));
+  const passed = gate?.get("passed");
+  const failing = gate?.get("failing");
+  const exposure = record(fields?.get("exposure"));
+  const declared = exposure?.get("declared");
+  const open = exposure?.get("open");
+  const unobservable = exposure?.get("unobservable");
+  return {
+    tenancy: typeof tenancy === "string" && isTenancy(tenancy) ? tenancy : null,
+    tenancyGate: typeof passed === "boolean" && Array.isArray(failing) ? {
+      passed,
+      failing: failing.filter((item) => typeof item === "string")
+    } : null,
+    exposure: typeof declared === "string" && isExposure(declared) && typeof open === "number" && typeof unobservable === "number" ? { declared, open, unobservable } : null
+  };
+};
+var declaredPostureLines = (posture) => [
+  ...posture.edgeHost === void 0 ? [] : [`edge \xB7 ${posture.edgeHost} \xB7 ${EDGE_IMAGE} on 80 and 443 \xB7 Mend's own port on loopback`],
+  `exposure \xB7 declared ${posture.exposure ?? "private"}${posture.exposure === void 0 ? " \xB7 the default, not set on this install" : ""}`,
+  `tenancy \xB7 declared ${posture.tenancy ?? "single"}${posture.tenancy === void 0 ? " \xB7 the default, not set on this install" : ""}`
+];
+var observedEdgeLine = (host, observed) => [
+  `edge \xB7 ${host}`,
+  observed.running ? "container running" : "container not running",
+  observed.certificate.kind === "observed" ? `certificate observed in Caddy's data \xB7 ${observed.certificate.file}` : observed.certificate.kind === "none" ? "no certificate in Caddy's data yet \xB7 mend server logs shows what Caddy tried" : `certificate not observed \xB7 ${observed.certificate.reason}`
+].join(" \xB7 ");
+var observedPostureLines = (posture, health) => {
+  const lines = [];
+  if (health.exposure === null) {
+    lines.push("exposure \xB7 observed \xB7 this server reports no exposure \xB7 it predates the gate");
+  } else {
+    const { declared, open, unobservable } = health.exposure;
+    const observable = open - unobservable;
+    lines.push(
+      [
+        `exposure \xB7 observed ${declared}`,
+        open === 0 ? "public exposure gate \xB7 nothing open" : `public exposure gate \xB7 ${open} item${open === 1 ? "" : "s"} open \xB7 ${observable} this build can observe \xB7 ${unobservable} no build can`,
+        "mend operator exposure lists them"
+      ].join(" \xB7 ")
+    );
+    if (posture.exposure !== void 0 && declared !== posture.exposure) {
+      lines.push(
+        `exposure \xB7 the running server declares ${declared}, this install ${posture.exposure}: it was started before the last mend server setup`
+      );
+    }
+  }
+  if (health.tenancy === null || health.tenancyGate === null) {
+    lines.push("tenancy \xB7 observed \xB7 this server reports no tenancy \xB7 it predates organizations");
+  } else {
+    const { failing } = health.tenancyGate;
+    lines.push(
+      [
+        `tenancy \xB7 observed ${health.tenancy}`,
+        failing.length === 0 ? "multi mode gate \xB7 nothing open" : `multi mode gate \xB7 open: ${failing.join(", ")}`,
+        "mend operator gate lists every item"
+      ].join(" \xB7 ")
+    );
+    if (posture.tenancy !== void 0 && health.tenancy !== posture.tenancy) {
+      lines.push(
+        `tenancy \xB7 the running server declares ${health.tenancy}, this install ${posture.tenancy}: it was started before the last mend server setup`
+      );
+    }
+  }
+  return lines;
+};
 
 // src/server-runtime.ts
 import { spawn } from "node:child_process";
-import * as fs4 from "node:fs";
-import * as path4 from "node:path";
+import * as fs5 from "node:fs";
+import * as path5 from "node:path";
 var serverProcessDeadlines = {
   ordinary: 3e4,
   pull: 10 * 6e4,
@@ -481,10 +1004,10 @@ var runServerProcess = (command, args, parentEnvironment, options = {}) => {
   ]) {
     if (parentEnvironment[key] !== void 0) env[key] = parentEnvironment[key];
   }
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     let fd;
     try {
-      if (options.stdoutFile !== void 0) fd = fs4.openSync(options.stdoutFile, "wx", 384);
+      if (options.stdoutFile !== void 0) fd = fs5.openSync(options.stdoutFile, "wx", 384);
       const child = spawn(command, [...args], {
         env,
         detached: process.platform !== "win32",
@@ -535,17 +1058,17 @@ var runServerProcess = (command, args, parentEnvironment, options = {}) => {
       child.once("close", (status) => {
         globalThis.clearTimeout(timer);
         try {
-          if (fd !== void 0) fs4.fsyncSync(fd);
+          if (fd !== void 0) fs5.fsyncSync(fd);
         } catch {
           failure2 ??= "Could not durably write process output.";
         } finally {
           try {
-            if (fd !== void 0) fs4.closeSync(fd);
+            if (fd !== void 0) fs5.closeSync(fd);
           } catch {
             failure2 ??= "Could not close process output file.";
           }
         }
-        resolve7({
+        resolve8({
           status: failure2 === void 0 ? status : null,
           stdout,
           stderr,
@@ -554,10 +1077,10 @@ var runServerProcess = (command, args, parentEnvironment, options = {}) => {
       });
     } catch (cause) {
       try {
-        if (fd !== void 0) fs4.closeSync(fd);
+        if (fd !== void 0) fs5.closeSync(fd);
       } catch {
       }
-      resolve7({
+      resolve8({
         status: null,
         stdout: "",
         stderr: "",
@@ -575,9 +1098,13 @@ var serverComposeArgs = (installation, command) => [
   "--project-directory",
   installation.directory,
   "--env-file",
-  path4.join(installation.directory, "server.env"),
+  path5.join(installation.directory, "server.env"),
   "-f",
-  path4.join(installation.directory, "compose.yaml"),
+  path5.join(installation.directory, "compose.yaml"),
+  ...(installation.overlays ?? []).flatMap((file) => [
+    "-f",
+    path5.join(installation.directory, file)
+  ]),
   ...command
 ];
 
@@ -623,11 +1150,11 @@ var mapLimit = async (items, limit, work) => {
   return results;
 };
 var pathOf = (command, env = process.env) => {
-  for (const directory of (env["PATH"] ?? "").split(path5.delimiter)) {
+  for (const directory of (env["PATH"] ?? "").split(path6.delimiter)) {
     if (directory === "") continue;
-    const candidate = path5.join(directory, command);
+    const candidate = path6.join(directory, command);
     try {
-      fs5.accessSync(candidate, fs5.constants.X_OK);
+      fs6.accessSync(candidate, fs6.constants.X_OK);
       return candidate;
     } catch {
     }
@@ -645,9 +1172,9 @@ var cliCollector = (deps) => ({
         node: process.versions.node,
         platform: process.platform,
         arch: process.arch,
-        osType: os3.type(),
-        osRelease: os3.release(),
-        hostname: os3.hostname(),
+        osType: os4.type(),
+        osRelease: os4.release(),
+        hostname: os4.hostname(),
         term: deps.env["TERM"] ?? null,
         shell: deps.env["SHELL"] ?? null,
         lang: deps.env["LANG"] ?? null,
@@ -694,7 +1221,13 @@ var serverConfigCollector = (facts) => ({
           envKeys: server.envKeys
         })
       },
-      { path: "server-compose.yaml", content: server.compose }
+      { path: "server-compose.yaml", content: server.compose },
+      // The generation's own overlays, when it has them: the edge and the posture name which
+      // variables reach the container and read every value from server.env, so they carry none.
+      ...server.overlays.map((overlay) => ({
+        path: `server-${overlay.name}`,
+        content: overlay.content
+      }))
     ];
   }
 });
@@ -706,7 +1239,8 @@ var serverLogsCollector = (deps, facts) => ({
     if (server === null) throw new Error(NO_SERVER);
     const installation = {
       directory: server.directory,
-      dockerContext: server.config.dockerContext
+      dockerContext: server.config.dockerContext,
+      overlays: composeOverlays(server.config)
     };
     const listed = await deps.run(
       "docker",
@@ -1023,9 +1557,9 @@ var sessionsCollector = (deps) => ({
           };
         }
         files2.push({ path: `sessions/${session.id}.json`, content: json(detail) });
-        const record = await recordFile(deps, detail);
-        if (record !== null)
-          files2.push({ path: `sessions/${session.id}-record.txt`, content: record });
+        const record2 = await recordFile(deps, detail);
+        if (record2 !== null)
+          files2.push({ path: `sessions/${session.id}-record.txt`, content: record2 });
         const services = new Set(
           detail.processes.flatMap((row) => row.serviceId === null ? [] : [row.serviceId])
         );
@@ -1056,7 +1590,7 @@ var sessionsCollector = (deps) => ({
             services: services.size,
             liveServices: detail.liveServices ?? null,
             detail: `sessions/${session.id}.json`,
-            record: record === null ? null : `sessions/${session.id}-record.txt`
+            record: record2 === null ? null : `sessions/${session.id}-record.txt`
           }
         };
       }
@@ -1117,8 +1651,8 @@ var bundleCollectors = (deps) => {
 };
 
 // src/doctor-bundle.ts
-import * as fs6 from "node:fs";
-import * as path6 from "node:path";
+import * as fs7 from "node:fs";
+import * as path7 from "node:path";
 import { gzipSync } from "node:zlib";
 
 // src/help.ts
@@ -1165,7 +1699,10 @@ var COMMANDS = [
     name: "connect",
     section: "start",
     summary: "send this machine's provider credential to the platform",
-    synopsis: ["<claude|codex|github> [--use-my-login] [--from-stdin] [--remove]"],
+    synopsis: [
+      "<claude|codex|github> [--use-my-login] [--from-stdin] [--remove]",
+      "pi [--dir <path>] [--dry-run] [--remove]"
+    ],
     description: [
       "Sessions run on the platform, so the platform needs your provider login. It is stored under your own user and used only for your work. Nothing is shared with other users.",
       "Claude and Codex get a login of Mend's own. Both rotate their refresh token, so two copies of one login fight and the one that refreshes second is signed out, and Mend's server refreshes on a schedule. So this logs in through the provider's own flow and your own login stays as it is: Claude in the browser, Codex with a device code, both sent and not kept here. Run it again whenever Mend says a login needs reconnecting. GitHub sends gh's token."
@@ -1183,7 +1720,24 @@ var COMMANDS = [
       { command: "mend connect codex", text: "a Codex login of Mend's own, with a device code" },
       { command: "mend connect github --remove", text: "" }
     ],
-    see: ["accounts"]
+    see: ["accounts", "connect pi"]
+  },
+  {
+    name: "connect pi",
+    section: "start",
+    summary: "send your pi setup to every pi session of yours",
+    synopsis: ["[--dir <path>] [--dry-run] [--remove]"],
+    description: [
+      "Reads pi's agent directory on this machine (~/.pi/agent, or $PI_CODING_AGENT_DIR) and saves it as your pi profile: extensions, themes, prompt templates, settings, mcp.json and keybindings. Every pi session you start receives it, and before pi starts the session installs the packages settings.json declares and what your extensions import. A package that fails to install is left out of that session, and the terminal says why.",
+      "Links are followed, so a setup a tool such as Home Manager links in is read as the files it points at. A package settings.json names by local path is copied into the profile. Your login stays here: pi runs on the ChatGPT login mend connect codex makes. Skills go with mend skills push. Run it again after you change your setup; sessions already running keep the profile they started with."
+    ],
+    options: [
+      { flag: "--dir <path>", text: "read another agent directory" },
+      { flag: "--dry-run", text: "say what would be sent, and send nothing" },
+      { flag: "--remove", text: "delete the saved profile" }
+    ],
+    examples: [{ command: "mend connect pi --dry-run", text: "what your pi profile would hold" }],
+    see: ["connect", "skills push"]
   },
   {
     name: "adopt",
@@ -1211,14 +1765,14 @@ var COMMANDS = [
   },
   {
     name: "codex",
-    aliases: ["claude", "opencode"],
+    aliases: ["claude", "opencode", "pi"],
     section: "start",
-    summary: "launch codex, claude, or opencode in a recorded worktree",
+    summary: "launch codex, claude, opencode or pi in a recorded worktree",
     synopsis: [
       '["prompt"] [--name <worktree>] [--worktree <existing>] [--model <id>] [--effort <level>] [--base <ref>] [--ask] [--fast] [--detach|-d] [--foreground] [--no-tunnel] [--land|--no-land] [--project <p>]'
     ],
     description: [
-      "mend codex, mend claude, and mend opencode are the same command with a different harness. The session runs in a workspace on the platform, in its own git worktree, and everything it does is recorded. This terminal attaches to it.",
+      "mend codex, mend claude, mend opencode and mend pi are the same command with a different harness. The session runs in a workspace on the platform, in its own git worktree, and everything it does is recorded. This terminal attaches to it.",
       "The worktree's name is asked first. --name skips the ask; an existing name joins that worktree as a new session. --worktree joins only and fails if the name is unknown. A quoted prompt becomes the first message.",
       "Detach with Ctrl+] and the session keeps running. Reattach from any terminal with mend attach, or from the phone.",
       tunnelText,
@@ -1228,8 +1782,14 @@ var COMMANDS = [
     options: [
       { flag: "--name <worktree>", text: "name the worktree; an existing name joins it" },
       { flag: "--worktree <existing>", text: "join an existing worktree only" },
-      { flag: "--model <id>", text: "the harness's model id" },
-      { flag: "--effort <level>", text: "low, medium, high, xhigh, or max" },
+      {
+        flag: "--model <id>",
+        text: "the harness's model id, one mend models lists. Default: the server's default for the harness"
+      },
+      {
+        flag: "--effort <level>",
+        text: "low, medium, high, xhigh, max, or ultra where the model takes it. Default: the harness's own"
+      },
       { flag: "--base <ref>", text: "the branch or sha the worktree starts from" },
       { flag: "--ask", text: "keep the harness's permission prompts" },
       { flag: "--fast", text: "priority processing where the harness offers it (codex)" },
@@ -1253,7 +1813,23 @@ var COMMANDS = [
         text: "a second session in the same worktree"
       }
     ],
-    see: ["attach", "stop", "run", "sessions", "land"]
+    see: ["attach", "stop", "run", "sessions", "land", "models"]
+  },
+  {
+    name: "models",
+    section: "start",
+    summary: "the models each harness offers, as the server lists them",
+    synopsis: ["[--json]"],
+    description: [
+      "One block per harness: each model's id, the one a launch runs when --model is not given, and the efforts a model takes where they are fewer than the harness's. The list is the server's; the phone, the web app, the desktop and VS Code offer the same one, and a session records which model it was started with.",
+      "Pass an id to mend claude or mend codex with --model. An id the list does not know is passed through as given; the harness decides whether it exists."
+    ],
+    options: [{ flag: "--json", text: "the catalog as the server answers it" }],
+    examples: [
+      { command: "mend models", text: "" },
+      { command: 'mend codex "fix the flaky test" --model gpt-6-astra --effort ultra', text: "" }
+    ],
+    see: ["codex", "sessions"]
   },
   {
     name: "pair",
@@ -1439,7 +2015,26 @@ var COMMANDS = [
     synopsis: ["[--project <p>] [--json]"],
     description: ["A worktree can hold several sessions over time; this shows them together."],
     options: [project(), { flag: "--json", text: "the v2 grouped shape" }],
-    see: ["sessions"]
+    see: ["sessions", "worktrees rm"]
+  },
+  {
+    name: "worktrees rm",
+    section: "sessions",
+    summary: "remove a worktree, its sessions and its change",
+    synopsis: ["<name> [--force] [--project <p>]"],
+    description: [
+      "Removes the worktree directory from the store, with every session in it, its change, its checkpoints and its review. Nothing on origin is touched. <name> is the worktree's name as mend worktrees lists it.",
+      "Refused while a session in it is live: the command names the sessions and the stops that free them. Refused while it holds a change that is not on origin, one never landed or one changed since its last landing: the refusal names the files and line counts, in the server's words. Land it with mend land, or pass --force to remove it anyway. A worktree whose workspace is still saving is refused until the save ends, and --force does not change that."
+    ],
+    options: [
+      { flag: "--force", text: "remove it although its change is not on origin" },
+      project()
+    ],
+    examples: [
+      { command: "mend worktrees rm fix-login", text: "refused when its change was never landed" },
+      { command: "mend worktrees rm fix-login --force", text: "remove it anyway" }
+    ],
+    see: ["worktrees", "land", "stop"]
   },
   {
     name: "projects",
@@ -1694,6 +2289,65 @@ var COMMANDS = [
     ],
     see: ["skills"]
   },
+  {
+    name: "memory",
+    section: "project setup",
+    summary: "what the agents remember about a project, for you",
+    synopsis: [
+      "[list] [--project <p>]",
+      "show <file> [--project <p>]",
+      "rm <file> [--project <p>]"
+    ],
+    description: [
+      "Claude Code and Codex write what they learn about a repository to their memory. Mend keeps that memory per person per project: every session you start on the project receives it, and what the agent learned is saved back when it ends. When two of your sessions change the same text file, both sides' lines are kept.",
+      "Codex builds its memory from your past conversations when a session starts, with model calls on your own login. Mend carries your earlier Codex conversations on the project into each new session so it has some to learn from.",
+      "This lists your memory for the project, prints one file, or removes one. Removing keeps the last version on the server. Other people's sessions never see it."
+    ],
+    options: [project()],
+    examples: [
+      { command: "mend memory", text: "your memory for the project in this directory" },
+      { command: "mend memory show MEMORY.md", text: "Claude's index of what it remembers" }
+    ],
+    see: ["memory import"]
+  },
+  {
+    name: "memory import",
+    section: "project setup",
+    summary: "bring this machine's claude and codex memory for the repository",
+    synopsis: ["[--project <p>] [--dry-run]"],
+    description: [
+      "Run inside the repository's checkout. Reads the memory Claude Code keeps on this machine for that directory, and the summaries Codex made of conversations held in it. Codex keeps one memory for everything, so only its summaries of this repository's conversations are read, never its consolidated memory. Transcripts, logins and settings are not read.",
+      "A file Mend does not have is added. A file both sides have with other contents is merged, keeping both sides' lines (a line both wrote at different places stays twice), and a note's frontmatter is merged key by key, with this machine's value kept as a comment where the two differ. Mend remembers what it imported from this checkout on this machine, so the next import from here takes whichever side changed since and merges only what both changed. A file Mend removed since then is not added again. A file it cannot merge stays as Mend has it, and this machine's is kept as a version, as it is when a merge does not hold every line this machine sent. Every version Mend replaces is kept."
+    ],
+    options: [
+      project(),
+      { flag: "--dry-run", text: "show what the import would do, and write nothing" }
+    ],
+    examples: [{ command: "mend memory import --dry-run", text: "" }],
+    see: ["memory", "adopt"]
+  },
+  {
+    name: "memory show",
+    section: "project setup",
+    summary: "print one memory file",
+    synopsis: ["<file> [--project <p>]"],
+    description: [
+      "Prints the file as Mend stores it, by the name mend memory lists. A name alone is Claude's; prefix another harness's with its name, as in codex:MEMORY.md."
+    ],
+    options: [project()],
+    see: ["memory"]
+  },
+  {
+    name: "memory rm",
+    section: "project setup",
+    summary: "remove one memory file",
+    synopsis: ["<file> [--project <p>]"],
+    description: [
+      "Removes the file from your memory for the project. Sessions already running keep their copy; the next launch does not deliver it, and a session that still holds it unchanged moves it aside. The last version stays on the server."
+    ],
+    options: [project()],
+    see: ["memory"]
+  },
   {
     name: "dotfiles",
     section: "project setup",
@@ -1747,6 +2401,47 @@ var COMMANDS = [
     options: [{ flag: "--all", text: "every known config file" }],
     see: ["dotfiles", "dotfiles repo"]
   },
+  {
+    name: "secrets",
+    section: "project setup",
+    summary: "your secret files: written into every session you launch",
+    synopsis: ["[list]"],
+    description: [
+      "A secret file is a file you keep in Mend, encrypted at rest, with its path under the home directory of the workspace: ~/.aws/credentials, a kubeconfig, an .npmrc token file. Every session you own receives your secret files before its agent starts, in every project. They are yours alone: no one else's sessions receive them, and the content never comes back out of the server. The web app's settings page shows the same list.",
+      "A secret file is never captured. It is written into the workspace's own home directory, which no capture, change, checkpoint or transcript harvest covers, and a path under a directory sessions do capture, such as .claude or .codex, is refused.",
+      "This lists your secret files: the path each takes in the workspace, its size, and when it last changed."
+    ],
+    examples: [{ command: "mend secrets", text: "" }],
+    see: ["secrets add", "secrets rm", "env load"]
+  },
+  {
+    name: "secrets add",
+    section: "project setup",
+    summary: "keep a file as a secret file, or replace one",
+    synopsis: ["<path> [--from <file>]"],
+    description: [
+      "Reads the content from <file>, or from stdin without --from, and keeps it at <path> under the workspace home. A path on this machine under your home, such as ~/.aws/credentials, names the same place in the workspace. A file already kept at that path is replaced. Sessions launched from then on receive it; a running session keeps what it has.",
+      "A file is at most 256 KB, and you may keep up to 64. Binary files are fine."
+    ],
+    options: [{ flag: "--from <file>", text: "read the content from this file instead of stdin" }],
+    examples: [
+      { command: "mend secrets add ~/.aws/credentials --from ~/.aws/credentials", text: "" },
+      { command: "mend secrets add .kube/config --from ~/.kube/config", text: "" },
+      { command: "mend secrets add .npmrc < ~/.npmrc", text: "" }
+    ],
+    see: ["secrets", "secrets rm"]
+  },
+  {
+    name: "secrets rm",
+    section: "project setup",
+    summary: "remove a secret file",
+    synopsis: ["<path>"],
+    description: [
+      "Removes the file kept at <path>. Sessions launched from then on do not receive it; a running session keeps what it has."
+    ],
+    examples: [{ command: "mend secrets rm .npmrc", text: "" }],
+    see: ["secrets"]
+  },
   {
     name: "git-author",
     section: "project setup",
@@ -1879,7 +2574,7 @@ var COMMANDS = [
     summary: "let everyone who can see a session steer it, or stop",
     synopsis: ["<session> on|off"],
     description: [
-      "The session's owner turns shared control on or off; an organization owner may turn it off. While it is on, anyone who can see the project sends turns, answers approvals, interrupts and types in the terminal, using your provider logins and Git access. Every act is recorded with who did it. A prefix of the session id is enough."
+      "The session's owner turns shared control on or off; an organization owner may turn it off. While it is on, anyone who can see the project sends turns, answers approvals and interrupts, using your provider logins and Git access. They can read the terminal; only the owner types in it, opens a shell or starts a Service. Every act is recorded with who did it. A prefix of the session id is enough."
     ],
     examples: [{ command: "mend session share 3f2a on", text: "" }],
     see: ["sessions"]
@@ -1987,11 +2682,13 @@ var COMMANDS = [
     section: "this machine",
     summary: "install or repair the local Mend server",
     synopsis: [
-      "[--context <name>] [--version <version|latest>] [--bind <ip>] [--url <origin>] [--origin <origin>...] [--port <n>] [--ssh-port <n>] [--docker-socket <path>] [--assets-dir <dir>] [--offline]"
+      "[--context <name>] [--version <version|latest>] [--bind <ip>] [--url <origin>] [--origin <origin>...] [--port <n>] [--ssh-port <n>] [--edge <host> | --no-edge] [--exposure <loopback|private|public>] [--tenancy <single|multi>] [--docker-socket <path>] [--assets-dir <dir>] [--offline]"
     ],
     description: [
       "Checks a local Unix-socket Docker context and the Compose plugin, downloads the compose and Postgres initialization assets for one Mend release, preserves existing data and secrets, and starts the server. Re-running repairs the same pinned version. A changed --version is refused; use mend server upgrade. Updating this CLI never updates an existing server pin.",
       "The default listens only on localhost at http://localhost:3105. Non-local access requires both --bind and --url. Every extra browser origin must be named with --origin; setup never guesses from the request Host header or network interfaces.",
+      "--edge <host> runs a TLS edge in front of Mend: Caddy on ports 80 and 443 of every interface, which obtains and renews a certificate for the host and proxies to Mend's web tier. Mend's own port stays on loopback and the browser origin is https://<host>. The edge's compose overlay and Caddyfile are written into the generation beside compose.yaml, so start, restart and upgrade run them every time. --no-edge takes it away again, and the edge's container with it. A fresh install cannot start with the edge: until the first account exists, registration is open to whoever reaches the origin first, so set up on localhost, create the account, then add the edge.",
+      "--exposure declares how the instance is reached, and --tenancy whether one organization or many use it. Both are written into the generation and kept across reruns and upgrades. public needs the edge and an existing first account. With multi, or with public, the multi mode gate's settings follow: MEND_SOURCE_POLICY=tenant and MEND_CAPTURE_REQUIRE_SIZES=true, and public sets MEND_URL_BEARERS=refuse. The server still decides whether it starts, and mend server status shows what it reports.",
       "Docker Desktop on Linux and macOS, and OrbStack on macOS, expose client-side proxy sockets. Containers use the daemon-side /var/run/docker.sock. --docker-socket overrides detection and is retained on reruns.",
       "Setup holds an exclusive process lock through startup and health checks. A busy lock reports its owner and manual recovery steps. Never remove a live lock. Private configuration uses immutable generations and an atomic active pointer; failed attempts retain credentials and never delete Docker volumes."
     ],
@@ -2015,6 +2712,19 @@ var COMMANDS = [
         flag: "--ssh-port <n>",
         text: "external workspace SSH port. Default: 2222; must differ from --port"
       },
+      {
+        flag: "--edge <host>",
+        text: "run the Caddy TLS edge for this DNS name on 80 and 443; the origin becomes https://<host>, --bind stays on loopback, and the first account must already exist"
+      },
+      { flag: "--no-edge", text: "take a saved edge away; the origin returns to http://localhost" },
+      {
+        flag: "--exposure <v>",
+        text: "declare loopback, private or public; kept across reruns and upgrades. public needs --edge and an existing first account"
+      },
+      {
+        flag: "--tenancy <v>",
+        text: "declare single or multi; kept across reruns and upgrades. multi also sets the multi mode gate's variables"
+      },
       {
         flag: "--assets-dir <dir>",
         text: "copy compose.v2.yaml and postgres-init.sh from a release directory; fresh setup requires --version"
@@ -2034,19 +2744,28 @@ var COMMANDS = [
       {
         command: "mend server setup --version 0.25.0 --assets-dir ./release-assets --offline",
         text: "install from local release assets and preloaded images"
+      },
+      {
+        command: "mend server setup --edge mend.example.com",
+        text: "a TLS edge for mend.example.com; its DNS points at this machine and 80 and 443 reach it"
+      },
+      {
+        command: "mend server setup --exposure public --tenancy multi",
+        text: "on an install with an edge and a first account: declare public, many organizations"
       }
     ],
-    see: ["server", "login", "doctor"]
+    see: ["server", "server status", "login", "doctor", "operator exposure"]
   },
   {
     name: "server status",
     section: "this machine",
-    summary: "show the saved pin, generation and container state",
+    summary: "show the pin, generation, containers, edge and posture",
     synopsis: [""],
     description: [
-      "Reads the existing installation without changing its files. A running Mend must answer health with the exact pinned version. A stopped server makes no health claim. Never installs a server implicitly."
+      "Reads the existing installation without changing its files. A running Mend must answer health with the exact pinned version. A stopped server makes no health claim. Never installs a server implicitly.",
+      "Then the posture, declared beside observed. Declared is what this install's configuration says: the edge host, MEND_EXPOSURE and MEND_TENANCY, a default named as one. Observed is what was seen: whether the edge's container runs and whether Caddy's data holds a certificate for the host, and what the running server reports in its health, the exposure it runs with and how many public exposure gate items are open, the tenancy and which multi mode gate items are open. When this machine is signed in to the install as the operator, every item of both gates follows with its detail, as mend operator gate and mend operator exposure print them. None of it is a verdict: the report says what was declared and what was observed."
     ],
-    see: ["server logs", "server start"]
+    see: ["server logs", "server start", "operator gate", "operator exposure"]
   },
   {
     name: "server start",
@@ -2062,10 +2781,10 @@ var COMMANDS = [
   {
     name: "server stop",
     section: "this machine",
-    summary: "stop Mend, Postgres and Garage without deleting data",
+    summary: "stop Mend, Postgres, Garage and the edge without deleting data",
     synopsis: [""],
     description: [
-      "Stops only the installation's Compose services. Connections are interrupted. Workspace containers and volumes remain, but active work may lose connectivity and need reconnection. No volume deletion or Docker prune is performed."
+      "Stops only the installation's Compose services, the edge among them when one is set. Connections are interrupted. Workspace containers and volumes remain, but active work may lose connectivity and need reconnection. No volume deletion or Docker prune is performed."
     ],
     see: ["server start", "server status"]
   },
@@ -2095,9 +2814,10 @@ var COMMANDS = [
     name: "server upgrade",
     section: "this machine",
     summary: "upgrade to an explicit version with a database backup",
-    synopsis: ["--version <target|latest> [--assets-dir <dir>] [--offline]"],
+    synopsis: ["--version <target|latest> [--assets-dir <dir>] [--offline] [--from-preview]"],
     description: [
       "Preflights release assets and the canonical image's version label before interrupting Mend. Downgrades are refused. latest is resolved only when explicitly requested; a same-version request does nothing.",
+      "The installed configuration stays: the bind, the origin, the ports, the edge host and the declared exposure and tenancy are carried into the new generation, which renders the same overlays beside the new compose.yaml. An upgrade never drops the edge or the posture; mend server setup is where they change.",
       "Stops app writers, starts official Postgres if needed, and streams pg_dumpall into a private database backup before selecting and starting the target. Connections are interrupted. Workspace containers and data are retained, but active work can lose connectivity and need reconnection. Stop any external database writers before upgrading.",
       "Preflight or backup failure retains the old pin and attempts to recover the old app if it was running. Once target startup may have begun, Mend never automatically downgrades or restores the database. The target pin, old generation and backup remain. Inspect logs, fix the target, then use mend server start. Recovery records are under the installation's backups/upgrade-UUID directory."
     ],
@@ -2113,6 +2833,10 @@ var COMMANDS = [
       {
         flag: "--offline",
         text: "no GitHub requests or release-image pulls; target assets and exact-version images must be local"
+      },
+      {
+        flag: "--from-preview",
+        text: "once, from a preview numbered X.Y.Z-preview.K to a next build X.Y.Z-next.N; refused unless the target carries every migration the server applied"
       }
     ],
     examples: [
@@ -2559,9 +3283,9 @@ var collectBundle = async (collectors) => {
 };
 var bundleFileName = (now) => `mend-bundle-${now.toISOString().replace(/\.\d{3}Z$/, "Z").replace(/:/g, "-")}.tgz`;
 var writeBundle = (files, outPath, now) => {
-  const directory = path6.dirname(outPath);
-  fs6.mkdirSync(directory, { recursive: true, mode: 448 });
-  const root = path6.basename(outPath).replace(/\.(?:tgz|tar\.gz)$/, "");
+  const directory = path7.dirname(outPath);
+  fs7.mkdirSync(directory, { recursive: true, mode: 448 });
+  const root = path7.basename(outPath).replace(/\.(?:tgz|tar\.gz)$/, "");
   const entries = files.map((file) => ({
     path: file.path,
     content: Buffer.from(file.content, "utf8")
@@ -2570,8 +3294,8 @@ var writeBundle = (files, outPath, now) => {
     entries.map((entry) => ({ path: `${root}/${entry.path}`, content: entry.content })),
     now
   );
-  fs6.writeFileSync(outPath, bytes, { mode: 384 });
-  fs6.chmodSync(outPath, 384);
+  fs7.writeFileSync(outPath, bytes, { mode: 384 });
+  fs7.chmodSync(outPath, 384);
   return {
     path: outPath,
     bytes: bytes.length,
@@ -2632,7 +3356,7 @@ var doctorBundleCommand = async (args, deps) => {
     return;
   }
   const now = deps.now();
-  const outPath = path6.resolve(parsed.args.out ?? path6.join(deps.defaultDir, bundleFileName(now)));
+  const outPath = path7.resolve(parsed.args.out ?? path7.join(deps.defaultDir, bundleFileName(now)));
   deps.warn("collecting \xB7 this can take a minute");
   const files = await collectBundle(deps.collectors(parsed.args.tail));
   const written = writeBundle(files, outPath, now);
@@ -2640,14 +3364,14 @@ var doctorBundleCommand = async (args, deps) => {
 };
 
 // src/doctor.ts
-import * as fs8 from "node:fs";
-import * as path8 from "node:path";
+import * as fs9 from "node:fs";
+import * as path9 from "node:path";
 
 // src/docker-shutdown.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
-import * as fs7 from "node:fs";
-import * as os4 from "node:os";
-import * as path7 from "node:path";
+import * as fs8 from "node:fs";
+import * as os5 from "node:os";
+import * as path8 from "node:path";
 var DOCKER_CAPTURE_STOP_GRACE_SECONDS = 3600;
 var DOCKERD_DEFAULT_SHUTDOWN_TIMEOUT_SECONDS = 15;
 var flagValue = (argv, name) => {
@@ -2672,12 +3396,12 @@ var daemonKindOf = (info) => {
 var defaultConfigPath = (facts, daemon) => {
   switch (daemon) {
     case "desktop":
-      return path7.join(facts.home, ".docker", "daemon.json");
+      return path8.join(facts.home, ".docker", "daemon.json");
     case "orbstack":
-      return path7.join(facts.home, ".orbstack", "config", "docker.json");
+      return path8.join(facts.home, ".orbstack", "config", "docker.json");
     case "rootless":
-      return path7.join(
-        facts.xdgConfigHome ?? path7.join(facts.home, ".config"),
+      return path8.join(
+        facts.xdgConfigHome ?? path8.join(facts.home, ".config"),
         "docker",
         "daemon.json"
       );
@@ -2806,7 +3530,7 @@ var parseDockerInfo = (stdout) => {
 };
 var readHostFile = (file) => {
   try {
-    return { kind: "read", text: fs7.readFileSync(file, "utf8") };
+    return { kind: "read", text: fs8.readFileSync(file, "utf8") };
   } catch (cause) {
     return cause instanceof Error && "code" in cause && cause.code === "ENOENT" ? { kind: "absent" } : { kind: "unreadable" };
   }
@@ -2814,21 +3538,21 @@ var readHostFile = (file) => {
 var hostProcView = {
   list: (dir) => {
     try {
-      return fs7.readdirSync(dir);
+      return fs8.readdirSync(dir);
     } catch {
       return null;
     }
   },
   read: (file) => {
     try {
-      return fs7.readFileSync(file, "utf8");
+      return fs8.readFileSync(file, "utf8");
     } catch {
       return null;
     }
   },
   link: (file) => {
     try {
-      return fs7.readlinkSync(file);
+      return fs8.readlinkSync(file);
     } catch {
       return null;
     }
@@ -2868,7 +3592,7 @@ var observeDockerd = (proc, host) => {
     const cmdline = proc.read(`/proc/${entry}/cmdline`);
     if (cmdline === null) continue;
     const argv = cmdline.split("\0").filter((arg) => arg !== "");
-    if (path7.basename(argv[0] ?? "") === "dockerd") daemons.push({ pid: entry, argv });
+    if (path8.basename(argv[0] ?? "") === "dockerd") daemons.push({ pid: entry, argv });
   }
   if (daemons.length === 0) return { kind: "none" };
   const socket = unixSocketOf(host);
@@ -2954,7 +3678,7 @@ var hostDockerDaemonFacts = (infoStdout) => ({
   info: infoStdout === null ? null : parseDockerInfo(infoStdout),
   ...dockerdFactsOf(observeDockerd(hostProcView, hostDockerEndpoint())),
   readFile: readHostFile,
-  home: os4.homedir(),
+  home: os5.homedir(),
   xdgConfigHome: process.env["XDG_CONFIG_HOME"] ?? null
 });
 var observeHostShutdownTimeout = () => {
@@ -3001,6 +3725,17 @@ var exposureCheck = (exposure) => {
     fix: plainBeyondMachine ? "serve it over https and set APP_URL to that origin" : gateOpen === 0 ? null : "mend operator exposure"
   };
 };
+var userNamespacesCheck = (observed) => observed.allowed ? {
+  label: "workspaces",
+  state: "ok",
+  detail: "the server's host allows rootless Docker",
+  fix: null
+} : {
+  label: "workspaces",
+  state: "failed",
+  detail: "the server's host refuses user namespaces \xB7 no workspace can start",
+  fix: observed.setting === null ? null : `on the server's host: ${hostUserNamespacesFix(observed.setting)}`
+};
 var LOGIN_COMMANDS = {
   claude: "claude setup-token",
   codex: "codex login",
@@ -3182,16 +3917,18 @@ var runChecks = async (config, probes) => {
   const machine = signedIn ? await getJson(config, "/machine") : null;
   const exposure = machine === null || machine.value === null ? void 0 : machine.value.exposure;
   checks.push(exposure === void 0 ? notChecked("exposure") : exposureCheck(exposure));
+  const userNamespaces = machine === null || machine.value === null ? void 0 : machine.value.userNamespaces;
+  if (userNamespaces !== void 0) checks.push(userNamespacesCheck(userNamespaces));
   if (probes.dockerShutdown !== void 0 && probes.onPath("docker")) {
     checks.push(dockerShutdownCheck(probes.dockerShutdown()));
   }
   return checks;
 };
 var onPath = (command) => {
-  for (const directory of (process.env["PATH"] ?? "").split(path8.delimiter)) {
+  for (const directory of (process.env["PATH"] ?? "").split(path9.delimiter)) {
     if (directory === "") continue;
     try {
-      fs8.accessSync(path8.join(directory, command), fs8.constants.X_OK);
+      fs9.accessSync(path9.join(directory, command), fs9.constants.X_OK);
       return true;
     } catch {
     }
@@ -3216,8 +3953,8 @@ var doctorCommand = async (config, localCredential2, claudeGrant2) => {
 };
 
 // src/dotfiles.ts
-import * as fs9 from "node:fs";
-import * as path9 from "node:path";
+import * as fs10 from "node:fs";
+import * as path10 from "node:path";
 var DOTFILE_CANDIDATES = [
   {
     group: "shell",
@@ -3258,44 +3995,44 @@ var DOTFILE_CANDIDATES = [
   }
 ];
 var MAX_FILE_BYTES = 1024 * 1024;
-var statFile = (home, relative4) => {
+var statFile = (home, relative5) => {
   try {
-    const stat = fs9.statSync(path9.join(home, relative4));
+    const stat = fs10.statSync(path10.join(home, relative5));
     return stat.isFile() ? stat : null;
   } catch {
     return null;
   }
 };
 var scanDotfileCandidates = (home) => DOTFILE_CANDIDATES.flatMap(
-  ({ group, paths }) => paths.flatMap((relative4) => {
-    const stat = statFile(home, relative4);
-    return stat === null ? [] : [{ path: relative4, group, bytes: stat.size }];
+  ({ group, paths }) => paths.flatMap((relative5) => {
+    const stat = statFile(home, relative5);
+    return stat === null ? [] : [{ path: relative5, group, bytes: stat.size }];
   })
 );
 var homeRelativePath = (home, requested) => {
-  const relative4 = path9.relative(home, path9.resolve(home, requested));
-  const outside = relative4 === "" || relative4 === ".." || relative4.startsWith(`..${path9.sep}`) || path9.isAbsolute(relative4);
-  return outside ? null : relative4.split(path9.sep).join("/");
+  const relative5 = path10.relative(home, path10.resolve(home, requested));
+  const outside = relative5 === "" || relative5 === ".." || relative5.startsWith(`..${path10.sep}`) || path10.isAbsolute(relative5);
+  return outside ? null : relative5.split(path10.sep).join("/");
 };
 var readSyncFiles = (home, paths_) => {
   const files = [];
   for (const requested of paths_) {
-    const relative4 = homeRelativePath(home, requested);
-    if (relative4 === null) {
+    const relative5 = homeRelativePath(home, requested);
+    if (relative5 === null) {
       return {
         error: `${requested} is not under ${home} \u2014 only files in your home directory sync`
       };
     }
-    const stat = statFile(home, relative4);
+    const stat = statFile(home, relative5);
     if (stat === null) {
-      return { error: `${relative4} is not a file under ${home}` };
+      return { error: `${relative5} is not a file under ${home}` };
     }
     if (stat.size > MAX_FILE_BYTES) {
-      return { error: `${relative4} is over 1MB \u2014 dotfiles are text; trim the selection` };
+      return { error: `${relative5} is over 1MB \u2014 dotfiles are text; trim the selection` };
     }
     files.push({
-      path: relative4,
-      contentsBase64: fs9.readFileSync(path9.join(home, relative4)).toString("base64"),
+      path: relative5,
+      contentsBase64: fs10.readFileSync(path10.join(home, relative5)).toString("base64"),
       // eslint-disable-next-line no-bitwise -- permission bits are the point
       mode: (stat.mode & 511).toString(8)
     });
@@ -3402,9 +4139,9 @@ var useHttp1 = () => {
 
 // src/landing.ts
 import { spawnSync as spawnSync4 } from "node:child_process";
-import * as fs10 from "node:fs";
-import * as os5 from "node:os";
-import * as path10 from "node:path";
+import * as fs11 from "node:fs";
+import * as os6 from "node:os";
+import * as path11 from "node:path";
 var paint = (code) => (text) => process.stdout.isTTY === true ? `[${code}m${text}[0m` : text;
 var dim = paint("2");
 var green = paint("32");
@@ -3642,9 +4379,9 @@ var gitRemotes = (cwd) => {
 var remoteForOrigin = (remotes, originUrl, cwd) => {
   if (originUrl === null) return null;
   const origin = normalizeRemoteUrl(originUrl);
-  const originPath = origin === null ? path10.resolve(originUrl.replace(/^file:\/\//, "")) : null;
+  const originPath = origin === null ? path11.resolve(originUrl.replace(/^file:\/\//, "")) : null;
   return remotes.find(
-    (remote) => origin === null ? path10.resolve(cwd, remote.url.replace(/^file:\/\//, "")) === originPath : normalizeRemoteUrl(remote.url) === origin
+    (remote) => origin === null ? path11.resolve(cwd, remote.url.replace(/^file:\/\//, "")) === originPath : normalizeRemoteUrl(remote.url) === origin
   ) ?? null;
 };
 var LOG_LINES = 10;
@@ -3667,10 +4404,10 @@ var fetchBundle = (cwd, bundle) => {
   const before = git(cwd, ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`]);
   const previous = before.status === 0 ? before.stdout.trim() : null;
   if (previous !== bundle.tip) {
-    const dir = fs10.mkdtempSync(path10.join(os5.tmpdir(), "mend-pull-"));
+    const dir = fs11.mkdtempSync(path11.join(os6.tmpdir(), "mend-pull-"));
     try {
-      const file = path10.join(dir, "change.bundle");
-      fs10.writeFileSync(file, bundle.bytes, { mode: 384 });
+      const file = path11.join(dir, "change.bundle");
+      fs11.writeFileSync(file, bundle.bytes, { mode: 384 });
       const fetched = git(cwd, [
         "fetch",
         "--no-tags",
@@ -3680,7 +4417,7 @@ var fetchBundle = (cwd, bundle) => {
       ]);
       if (fetched.status !== 0) return refusedWith(gitWords(fetched));
     } finally {
-      fs10.rmSync(dir, { recursive: true, force: true });
+      fs11.rmSync(dir, { recursive: true, force: true });
     }
   }
   const after = git(cwd, ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`]).stdout.trim();
@@ -3803,7 +4540,9 @@ var agentRuns = (agent) => agent !== null && agent.kind !== "agent-protocol" &&
 var startingLineOf = (session) => {
   const summary = session.summary?.trim() ?? "";
   if (summary === "") return session.status;
-  if (/^[a-z][a-z -]*·/u.test(summary)) return summary;
+  if (/^(starting|running|waiting|idle|stopping|completed|failed|stopped) ·/u.test(summary)) {
+    return summary;
+  }
   return `${session.status} \xB7 ${summary}`;
 };
 var refusalOf = (error) => error instanceof MendRequestError && error.kind === "http" && (error.status === null || !GATEWAY_STATUSES.has(error.status)) ? error.message : null;
@@ -3871,7 +4610,7 @@ var followStart = async (options) => {
 
 // src/login.ts
 import { spawn as spawn2 } from "node:child_process";
-import * as os6 from "node:os";
+import * as os7 from "node:os";
 
 // src/pair.ts
 var paint2 = (code) => (text) => process.stdout.isTTY === true ? `\x1B[${code}m${text}\x1B[0m` : text;
@@ -4045,7 +4784,7 @@ var retryAfterSecondsOf = (json2) => {
   }
   return 5;
 };
-var sleep2 = (ms) => new Promise((resolve7) => setTimeout(resolve7, ms));
+var sleep2 = (ms) => new Promise((resolve8) => setTimeout(resolve8, ms));
 var resolveServerUrl = async (args, deps) => {
   const given = takeFlagValue2(args, "--url") ?? deps.configuredUrl;
   if (given !== null) {
@@ -4063,7 +4802,7 @@ var resolveServerUrl = async (args, deps) => {
 };
 var loginCommand = async (args, deps) => {
   const base = await resolveServerUrl(args, deps);
-  const started = await post(`${base}/api/cli/auth`, { name: os6.hostname() });
+  const started = await post(`${base}/api/cli/auth`, { name: os7.hostname() });
   if (started.status === 429) {
     return fail3(
       `the server asked for a pause \u2014 try again in ${retryAfterSecondsOf(started.json)}s`
@@ -4113,9 +4852,42 @@ var loginCommand = async (args, deps) => {
   return fail3("the authorize request expired before anyone approved \u2014 run mend login again");
 };
 
+// src/models.ts
+var contiguousIn = (efforts, scale) => {
+  const from = scale.indexOf(efforts[0] ?? "");
+  return from >= 0 && efforts.every((effort, index) => scale[from + index] === effort);
+};
+var effortRange = (efforts, scale) => efforts.length === 0 ? "none" : efforts.length <= 2 || !contiguousIn(efforts, scale) ? efforts.join(", ") : `${efforts[0]} \u2026 ${efforts.at(-1)}`;
+var modelCatalogLines = (catalogs, dim7 = (text) => text) => {
+  if (catalogs.length === 0)
+    return ["no models listed \xB7 the server's harness_models table is empty"];
+  const lines = [];
+  for (const [index, catalog] of catalogs.entries()) {
+    if (index > 0) lines.push("");
+    const efforts = effortRange(catalog.efforts, catalog.efforts);
+    lines.push(
+      `${catalog.harness}  ${dim7(`effort ${efforts}${catalog.fastCapable ? " \xB7 --fast" : ""}`)}`
+    );
+    const idWidth = Math.max(...catalog.models.map((model) => model.id.length));
+    for (const model of catalog.models) {
+      const facts = [];
+      if (model.id === catalog.defaultModel) facts.push("default");
+      if (model.efforts !== null) {
+        facts.push(`effort ${effortRange(model.efforts, catalog.efforts)}`);
+      }
+      lines.push(
+        `  ${model.id.padEnd(idWidth)}  ${model.label}${facts.length === 0 ? "" : `  ${dim7(facts.join(" \xB7 "))}`}`
+      );
+    }
+    if (catalog.models.length === 0) lines.push(`  ${dim7("no models listed \xB7 the harness picks")}`);
+  }
+  return lines;
+};
+var modelCatalogJson = (catalogs) => JSON.stringify({ version: 1, harnesses: catalogs }, null, 2);
+
 // src/organization.ts
-import * as fs11 from "node:fs";
-import * as path11 from "node:path";
+import * as fs12 from "node:fs";
+import * as path12 from "node:path";
 var paint4 = (code) => (text) => process.stdout.isTTY === true ? `[${code}m${text}[0m` : text;
 var dim4 = paint4("2");
 var green4 = paint4("32");
@@ -4178,23 +4950,23 @@ var SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set([".git", "node_modules"]);
 var scanFolder = (dir) => {
   const files = [];
   const skipped = [];
-  const walk = (relative4) => {
-    const entries = fs11.readdirSync(path11.join(dir, relative4), { withFileTypes: true }).toSorted((a, b) => a.name.localeCompare(b.name));
+  const walk2 = (relative5) => {
+    const entries = fs12.readdirSync(path12.join(dir, relative5), { withFileTypes: true }).toSorted((a, b) => a.name.localeCompare(b.name));
     for (const entry of entries) {
-      const child = relative4 === "" ? entry.name : `${relative4}/${entry.name}`;
+      const child = relative5 === "" ? entry.name : `${relative5}/${entry.name}`;
       if (entry.isSymbolicLink()) {
         skipped.push({ path: child, reason: "symlink" });
       } else if (entry.isDirectory()) {
         if (SKIPPED_DIRECTORIES.has(entry.name)) skipped.push({ path: child, reason: "skipped" });
-        else walk(child);
+        else walk2(child);
       } else if (entry.isFile()) {
-        const size = fs11.statSync(path11.join(dir, child)).size;
+        const size = fs12.statSync(path12.join(dir, child)).size;
         if (size > FOLDER_FILE_BYTES) skipped.push({ path: child, reason: "over 1 MiB" });
         else files.push({ path: child, size });
       }
     }
   };
-  walk("");
+  walk2("");
   return { files, skipped };
 };
 var uploadBatches = (files, cap = FOLDER_REQUEST_BYTES) => {
@@ -4241,7 +5013,7 @@ var folderCommand = async (api2, args) => {
     }
     case "push": {
       if (dir === void 0) return fail4("usage: mend folder push <name> <dir> [--replace]");
-      if (!fs11.existsSync(dir) || !fs11.statSync(dir).isDirectory()) {
+      if (!fs12.existsSync(dir) || !fs12.statSync(dir).isDirectory()) {
         return fail4(`${dir} is not a directory`);
       }
       const folder = await folderNamed(api2, name);
@@ -4256,7 +5028,7 @@ var folderCommand = async (api2, args) => {
           files: batch.map((file) => ({
             path: file.path,
             // Read one batch at a time, so a large tree never sits in memory at once.
-            contentsBase64: fs11.readFileSync(path11.join(dir, file.path)).toString("base64")
+            contentsBase64: fs12.readFileSync(path12.join(dir, file.path)).toString("base64")
           })),
           // --replace empties the folder with the first batch; the rest add to it.
           merge: !(replace && index === 0)
@@ -4436,12 +5208,334 @@ var operatorCommand = async (api2, tryApi, baseUrl, args) => {
   return fail4(`unknown operator command "${first ?? ""}" \xB7 mend help operator org list`);
 };
 
+// src/pi-profile.ts
+import * as fs13 from "node:fs";
+import * as os8 from "node:os";
+import * as path13 from "node:path";
+var piAgentDir = () => process.env["PI_CODING_AGENT_DIR"] ?? path13.join(os8.homedir(), ".pi", "agent");
+var RESOURCE_DIRS = ["extensions", "themes", "prompts"];
+var BESIDE = [
+  ["package.json", "package.json"],
+  ["package-lock.json", "package-lock.json"],
+  ["mcp.json", "root/mcp.json"],
+  ["keybindings.json", "root/keybindings.json"]
+];
+var MACHINE_SETTINGS = /* @__PURE__ */ new Set(["lastChangelogVersion"]);
+var LEFT_HERE_WHY = {
+  "auth.json": "auth.json (pi runs on your ChatGPT login: mend connect codex)",
+  skills: "skills (mend skills push --dir <agent dir>/skills)",
+  "AGENTS.md": "AGENTS.md (Mend writes its workspace note there)",
+  npm: "npm (the session installs what settings.json declares)",
+  git: "git (the session installs what settings.json declares)"
+};
+var SILENT = /* @__PURE__ */ new Set(["node_modules", "settings.json", ".gitignore"]);
+var SKIPPED_DIRS = /* @__PURE__ */ new Set([".git", "node_modules"]);
+var utf8 = new TextDecoder("utf-8", { fatal: true });
+var asProfileFile = (profilePath, bytes) => {
+  if (!bytes.includes(0)) {
+    try {
+      return { path: profilePath, encoding: "utf8", contents: utf8.decode(bytes) };
+    } catch {
+    }
+  }
+  return { path: profilePath, encoding: "base64", contents: bytes.toString("base64") };
+};
+var walk = (root, notes) => {
+  const found = [];
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (dir, rel) => {
+    let real;
+    try {
+      real = fs13.realpathSync(dir);
+    } catch {
+      return;
+    }
+    if (seen.has(real)) return;
+    seen.add(real);
+    for (const name of fs13.readdirSync(dir).toSorted()) {
+      if (SKIPPED_DIRS.has(name)) continue;
+      const abs = path13.join(dir, name);
+      const relPath = rel === "" ? name : `${rel}/${name}`;
+      let stat;
+      try {
+        stat = fs13.statSync(abs);
+      } catch {
+        notes.push(`${relPath}: a link to nothing, left out`);
+        continue;
+      }
+      if (stat.isDirectory()) visit(abs, relPath);
+      else if (stat.isFile()) found.push([abs, relPath]);
+    }
+  };
+  visit(root, "");
+  return found;
+};
+var isLocalSource = (source) => !/^(npm|git):/.test(source) && !/^(https?|ssh|git):\/\//.test(source) && !source.startsWith("git@");
+var expandHome = (source) => source === "~" || source.startsWith("~/") ? path13.join(os8.homedir(), source.slice(1)) : source;
+var bundleName = (abs) => {
+  try {
+    const manifest = JSON.parse(fs13.readFileSync(path13.join(abs, "package.json"), "utf8"));
+    if (manifest !== null && typeof manifest === "object" && "name" in manifest) {
+      const name = manifest.name;
+      if (typeof name === "string" && name !== "") return name.split("/").at(-1) ?? name;
+    }
+  } catch {
+  }
+  return path13.basename(abs).replace(/^[0-9a-z]{32}-/, "");
+};
+var HOST_PROVIDED = (name) => name.startsWith("@earendil-works/") || name === "typebox";
+var versionOf = (dir) => {
+  try {
+    const manifest = JSON.parse(fs13.readFileSync(path13.join(dir, "package.json"), "utf8"));
+    return manifest !== null && typeof manifest === "object" && "version" in manifest && typeof manifest.version === "string" ? manifest.version : null;
+  } catch {
+    return null;
+  }
+};
+var installedPackages = (nodeModules) => {
+  const names = fs13.readdirSync(nodeModules).flatMap((entry) => {
+    if (entry.startsWith(".")) return [];
+    if (!entry.startsWith("@")) return [entry];
+    try {
+      return fs13.readdirSync(path13.join(nodeModules, entry)).map((scoped) => `${entry}/${scoped}`);
+    } catch {
+      return [];
+    }
+  });
+  const dependencies = {};
+  for (const name of names.toSorted()) {
+    if (HOST_PROVIDED(name)) continue;
+    const version = versionOf(path13.join(nodeModules, name));
+    if (version !== null) dependencies[name] = version;
+  }
+  return dependencies;
+};
+var scanPiProfile = (agentDir) => {
+  if (!fs13.existsSync(agentDir) || !fs13.statSync(agentDir).isDirectory()) {
+    return { error: `no pi agent directory at ${agentDir}; run pi once, or pass --dir` };
+  }
+  const notes = [];
+  const files = [];
+  const add = (abs, profilePath) => {
+    const bytes = fs13.readFileSync(abs);
+    if (bytes.byteLength > PI_PROFILE_MAX_FILE_BYTES) {
+      notes.push(`${profilePath}: over ${PI_PROFILE_MAX_FILE_BYTES / (1024 * 1024)} MB, left out`);
+      return;
+    }
+    files.push(asProfileFile(profilePath, bytes));
+  };
+  for (const dir of RESOURCE_DIRS) {
+    const abs = path13.join(agentDir, dir);
+    if (!fs13.existsSync(abs)) continue;
+    for (const [file, rel] of walk(abs, notes)) add(file, `${dir}/${rel}`);
+  }
+  const beside = [];
+  for (const [name, profilePath] of BESIDE) {
+    const abs = path13.join(agentDir, name);
+    if (!fs13.existsSync(abs) || !fs13.statSync(abs).isFile()) continue;
+    add(abs, profilePath);
+    beside.push(name);
+  }
+  const nodeModules = path13.join(agentDir, "node_modules");
+  if (!beside.includes("package.json") && fs13.existsSync(nodeModules)) {
+    const dependencies = installedPackages(nodeModules);
+    const count = Object.keys(dependencies).length;
+    if (count > 0) {
+      files.push({
+        path: "package.json",
+        encoding: "utf8",
+        contents: `${JSON.stringify(
+          {
+            name: "pi-agent-dependencies",
+            private: true,
+            description: "Written by mend connect pi from the node_modules beside your extensions",
+            dependencies
+          },
+          null,
+          2
+        )}
+`
+      });
+      beside.push(`package.json (written from node_modules: ${count} packages)`);
+    }
+  }
+  const packages = [];
+  let settingNames = [];
+  const settingsPath = path13.join(agentDir, "settings.json");
+  if (fs13.existsSync(settingsPath)) {
+    let settings;
+    try {
+      settings = JSON.parse(fs13.readFileSync(settingsPath, "utf8"));
+    } catch {
+      settings = null;
+    }
+    if (settings === null || typeof settings !== "object" || Array.isArray(settings)) {
+      return { error: `${settingsPath} is not a JSON object; fix it or move it aside first` };
+    }
+    const carried = {};
+    const names = /* @__PURE__ */ new Set();
+    for (const [key, value] of Object.entries(settings)) {
+      if (MACHINE_SETTINGS.has(key)) continue;
+      if (key !== "packages") {
+        carried[key] = value;
+        continue;
+      }
+      if (!Array.isArray(value)) {
+        notes.push("settings.json: packages is not a list, left out");
+        continue;
+      }
+      const declared = [];
+      for (const entry of value) {
+        const source = typeof entry === "string" ? entry : entry !== null && typeof entry === "object" && "source" in entry ? entry.source : null;
+        if (typeof source !== "string") {
+          notes.push(`settings.json: a package entry without a source, left out`);
+          continue;
+        }
+        if (!isLocalSource(source)) {
+          declared.push(entry);
+          packages.push({ source, from: null });
+          continue;
+        }
+        const abs = path13.resolve(agentDir, expandHome(source));
+        if (!fs13.existsSync(abs)) {
+          notes.push(`package ${source}: not on this machine, left out`);
+          continue;
+        }
+        let name = bundleName(abs);
+        for (let n = 2; names.has(name); n += 1) name = `${bundleName(abs)}-${n}`;
+        names.add(name);
+        const bundled = `${PI_PROFILE_LOCAL_PACKAGES}/${name}`;
+        if (fs13.statSync(abs).isDirectory()) {
+          for (const [file, rel] of walk(abs, notes)) add(file, `${bundled}/${rel}`);
+        } else {
+          add(abs, `${bundled}/${path13.basename(abs)}`);
+        }
+        const rewritten = `./${PI_PROFILE_AGENT_PATH}/${bundled}${fs13.statSync(abs).isDirectory() ? "" : `/${path13.basename(abs)}`}`;
+        declared.push(
+          entry !== null && typeof entry === "object" ? { ...entry, source: rewritten } : rewritten
+        );
+        packages.push({ source: rewritten, from: source });
+      }
+      carried["packages"] = declared;
+    }
+    settingNames = Object.keys(carried).filter((key) => key !== "packages");
+    files.push({
+      path: "settings.json",
+      encoding: "utf8",
+      contents: `${JSON.stringify(carried, null, 2)}
+`
+    });
+  }
+  const mcpPath = path13.join(agentDir, "mcp.json");
+  if (fs13.existsSync(mcpPath)) {
+    try {
+      const mcp = JSON.parse(fs13.readFileSync(mcpPath, "utf8"));
+      const servers = mcp !== null && typeof mcp === "object" && "mcpServers" in mcp ? mcp.mcpServers : null;
+      if (servers !== null && typeof servers === "object") {
+        for (const [name, server] of Object.entries(servers)) {
+          const command = server !== null && typeof server === "object" && "command" in server ? server.command : null;
+          if (typeof command === "string" && path13.isAbsolute(command)) {
+            notes.push(
+              `mcp.json: server ${name} runs ${command}, a path on this machine a session may not have`
+            );
+          }
+        }
+      }
+    } catch {
+      notes.push("mcp.json: not JSON; sent as it is");
+    }
+  }
+  const carriedTop = /* @__PURE__ */ new Set([...RESOURCE_DIRS, ...BESIDE.map(([name]) => name)]);
+  const leftHere = fs13.readdirSync(agentDir).toSorted().filter((name) => !carriedTop.has(name) && !SILENT.has(name)).map((name) => LEFT_HERE_WHY[name] ?? name);
+  return {
+    agentDir,
+    files,
+    bytes: files.reduce(
+      (sum, file) => sum + (file.encoding === "utf8" ? Buffer.byteLength(file.contents, "utf8") : Buffer.from(file.contents, "base64").byteLength),
+      0
+    ),
+    extensions: [
+      ...new Set(
+        files.flatMap((file) => {
+          const [top, name] = file.path.split("/");
+          return top === "extensions" && name !== void 0 ? [name] : [];
+        })
+      )
+    ],
+    themes: files.filter((file) => file.path.startsWith("themes/") && file.path.endsWith(".json")).length,
+    prompts: files.filter((file) => file.path.startsWith("prompts/") && file.path.endsWith(".md")).length,
+    packages,
+    settings: settingNames,
+    beside,
+    leftHere,
+    notes
+  };
+};
+var megabytes = (bytes) => bytes < 1024 * 1024 ? `${Math.max(1, Math.round(bytes / 1024))} KB` : `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+var list = (items) => items.length === 0 ? "none" : items.join(", ");
+var piProfileLines = (scan) => {
+  return [
+    `pi profile \xB7 ${scan.agentDir} \xB7 ${scan.files.length} files \xB7 ${megabytes(scan.bytes)}`,
+    `  extensions  ${scan.extensions.length === 0 ? "none" : `${scan.extensions.length} \xB7 ${list(scan.extensions)}`}`,
+    `  themes      ${scan.themes}`,
+    `  prompts     ${scan.prompts}`,
+    `  packages    ${list(
+      scan.packages.map(
+        (entry) => entry.from === null ? entry.source : `${entry.from} (copied in)`
+      )
+    )}`,
+    `  settings    ${list(scan.settings)}`,
+    ...scan.beside.length === 0 ? [] : [
+      `  also        ${list(
+        scan.beside.map(
+          (name) => name === "mcp.json" ? "mcp.json (as it is, with any keys in it)" : name
+        )
+      )}`
+    ],
+    ...scan.leftHere.length === 0 ? [] : [`  left here   ${list(scan.leftHere)}`],
+    ...scan.notes.map((note) => `  ! ${note}`)
+  ];
+};
+
+// src/secret-files.ts
+import * as path14 from "node:path";
+var secretFilePathOf = (input, home) => {
+  const trimmed = input.trim();
+  let relative5 = trimmed;
+  if (trimmed === "~" || trimmed.startsWith("~/")) relative5 = trimmed.slice(2);
+  else if (path14.isAbsolute(trimmed)) {
+    const fromHome = path14.relative(home, trimmed);
+    if (fromHome === "" || fromHome.startsWith("..") || path14.isAbsolute(fromHome)) {
+      return {
+        path: null,
+        issue: `${trimmed} is outside your home directory; name the path under the workspace home, as .aws/credentials`
+      };
+    }
+    relative5 = fromHome;
+  }
+  const normalized = path14.posix.normalize(relative5).replace(/^(\.\/)+/, "").replace(/\/$/, "");
+  const issue = validateSecretFilePath(normalized === "." ? "" : normalized);
+  return issue === null ? { path: normalized, issue: null } : { path: null, issue };
+};
+var secretFileUploadOf = (filePath, bytes) => {
+  const text = bytes.includes(0) ? null : bytes.toString("utf8");
+  return text !== null && Buffer.from(text, "utf8").equals(bytes) ? { path: filePath, encoding: "utf8", contents: text } : { path: filePath, encoding: "base64", contents: bytes.toString("base64") };
+};
+var sizeOf = (bytes) => bytes < 1024 ? `${bytes} B` : `${(bytes / 1024).toFixed(1)} KB`;
+var secretFileLines = (files) => {
+  const width = Math.max(0, ...files.map((file) => file.path.length + 2));
+  return files.map(
+    (file) => `~/${file.path}`.padEnd(width) + `  ${sizeOf(file.bytes).padStart(8)}  ${file.updatedAt.slice(0, 16).replace("T", " ")}` + (file.revision > 1 ? ` \xB7 replaced ${file.revision - 1} time${file.revision === 2 ? "" : "s"}` : "")
+  );
+};
+
 // src/server-setup.ts
 import { createHmac, randomBytes } from "node:crypto";
+import * as fs16 from "node:fs";
 import { readFile } from "node:fs/promises";
-import * as net2 from "node:net";
-import * as os8 from "node:os";
-import * as path13 from "node:path";
+import * as net3 from "node:net";
+import * as os10 from "node:os";
+import * as path16 from "node:path";
 
 // src/server-docker-volumes.ts
 import { createHash as createHash2 } from "node:crypto";
@@ -4658,10 +5752,10 @@ var claimServerDockerVolumes = (runtime, input) => ownership(runtime, input, "cl
 var verifyServerDockerVolumes = (runtime, input) => ownership(runtime, input, "verify");
 
 // src/server-store.ts
-import { randomUUID } from "node:crypto";
-import * as fs12 from "node:fs";
-import * as os7 from "node:os";
-import * as path12 from "node:path";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import * as fs14 from "node:fs";
+import * as os9 from "node:os";
+import * as path15 from "node:path";
 var ServerStoreError = class extends Error {
   _tag = "ServerStoreError";
 };
@@ -4682,38 +5776,53 @@ var attempt = (operation) => {
 var hasCode = (cause, code) => cause instanceof Error && "code" in cause && cause.code === code;
 var readOptional = (file) => {
   try {
-    return fs12.readFileSync(file, "utf8");
+    return fs14.readFileSync(file, "utf8");
   } catch (cause) {
     if (hasCode(cause, "ENOENT")) return null;
     throw cause;
   }
 };
 var syncDirectory = (directory) => {
-  const fd = fs12.openSync(directory, "r");
+  const fd = fs14.openSync(directory, "r");
   try {
-    fs12.fsyncSync(fd);
+    fs14.fsyncSync(fd);
   } finally {
-    fs12.closeSync(fd);
+    fs14.closeSync(fd);
   }
 };
 var writeDurable = (file, content, mode = 384) => {
-  const fd = fs12.openSync(file, "wx", mode);
+  const fd = fs14.openSync(file, "wx", mode);
   try {
-    fs12.writeFileSync(fd, content, "utf8");
-    fs12.fchmodSync(fd, mode);
-    fs12.fsyncSync(fd);
+    fs14.writeFileSync(fd, content, "utf8");
+    fs14.fchmodSync(fd, mode);
+    fs14.fsyncSync(fd);
   } finally {
-    fs12.closeSync(fd);
+    fs14.closeSync(fd);
   }
 };
 var fileKeys = ["identity", "config", "env", "compose", "postgresInit"];
+var optionalFileKeys = ["posture", "edge", "caddyfile"];
 var fileNames = {
   identity: "identity.env",
   config: "server.json",
   env: "server.env",
   compose: "compose.yaml",
-  postgresInit: "postgres-init.sh"
-};
+  postgresInit: "postgres-init.sh",
+  posture: "compose.posture.yaml",
+  edge: "compose.edge.yaml",
+  caddyfile: "Caddyfile"
+};
+var fileModes = {
+  identity: 384,
+  config: 384,
+  env: 384,
+  compose: 384,
+  postgresInit: 493,
+  posture: 384,
+  edge: 384,
+  caddyfile: 420
+};
+var allFiles = (files) => [...fileKeys, ...optionalFileKeys].map((key) => [key, files[key]]);
 var parseLockOwner = (raw) => {
   if (typeof raw !== "object" || raw === null || !("pid" in raw) || !("hostname" in raw))
     return null;
@@ -4723,11 +5832,11 @@ var parseLockOwner = (raw) => {
 };
 var describeOwner = (lockDir) => {
   try {
-    const raw = JSON.parse(fs12.readFileSync(path12.join(lockDir, "owner.json"), "utf8"));
+    const raw = JSON.parse(fs14.readFileSync(path15.join(lockDir, "owner.json"), "utf8"));
     const owner = parseLockOwner(raw);
     if (owner === null) return "owner metadata is invalid";
     const label = `PID ${owner.pid} on ${owner.hostname}`;
-    if (owner.hostname !== os7.hostname()) return label;
+    if (owner.hostname !== os9.hostname()) return label;
     try {
       process.kill(owner.pid, 0);
       return `${label} is still live`;
@@ -4743,28 +5852,28 @@ var lockGuidance = (lockDir) => new ServerStoreError(
 );
 var acquireLock = (configDir, create) => {
   if (create) {
-    fs12.mkdirSync(configDir, { recursive: true, mode: 448 });
-    fs12.chmodSync(configDir, 448);
-  } else if (!fs12.existsSync(configDir)) {
+    fs14.mkdirSync(configDir, { recursive: true, mode: 448 });
+    fs14.chmodSync(configDir, 448);
+  } else if (!fs14.existsSync(configDir)) {
     throw new ServerStoreError(
       "No Mend server is configured. Run mend server setup explicitly to install one."
     );
   }
-  const lockDir = path12.join(configDir, "server.lock");
+  const lockDir = path15.join(configDir, "server.lock");
   try {
-    fs12.mkdirSync(lockDir, { mode: 448 });
+    fs14.mkdirSync(lockDir, { mode: 448 });
   } catch (cause) {
     if (hasCode(cause, "EEXIST")) throw lockGuidance(lockDir);
     throw cause;
   }
-  const owned = fs12.statSync(lockDir);
-  const ownerFile = path12.join(lockDir, "owner.json");
-  const owner = `${JSON.stringify({ pid: process.pid, hostname: os7.hostname(), token: randomUUID() })}
+  const owned = fs14.statSync(lockDir);
+  const ownerFile = path15.join(lockDir, "owner.json");
+  const owner = `${JSON.stringify({ pid: process.pid, hostname: os9.hostname(), token: randomUUID2() })}
 `;
   let open = true;
   const assertOwned = () => {
-    const current = fs12.statSync(lockDir);
-    if (!open || current.dev !== owned.dev || current.ino !== owned.ino || fs12.readFileSync(ownerFile, "utf8") !== owner) {
+    const current = fs14.statSync(lockDir);
+    if (!open || current.dev !== owned.dev || current.ino !== owned.ino || fs14.readFileSync(ownerFile, "utf8") !== owner) {
       throw new ServerStoreError(
         "Server lock ownership was lost. Stop and check for another server command before retrying."
       );
@@ -4780,8 +5889,8 @@ var acquireLock = (configDir, create) => {
     release: () => {
       const result = attempt(() => {
         assertOwned();
-        fs12.unlinkSync(ownerFile);
-        fs12.rmdirSync(lockDir);
+        fs14.unlinkSync(ownerFile);
+        fs14.rmdirSync(lockDir);
       });
       open = false;
       return result;
@@ -4790,7 +5899,7 @@ var acquireLock = (configDir, create) => {
 };
 var readIdentity = (paths) => {
   const identity = readOptional(paths.identity);
-  if (identity === null && (fs12.existsSync(paths.active) || fs12.existsSync(paths.generations) && fs12.readdirSync(paths.generations).length > 0)) {
+  if (identity === null && (fs14.existsSync(paths.active) || fs14.existsSync(paths.generations) && fs14.readdirSync(paths.generations).length > 0)) {
     throw new ServerStoreError(
       "Server identity.env is missing. Restore it from a retained generation or backup; refusing to generate replacement credentials."
     );
@@ -4800,7 +5909,7 @@ var readIdentity = (paths) => {
 var readActive = (paths) => {
   let target;
   try {
-    target = fs12.readlinkSync(paths.active);
+    target = fs14.readlinkSync(paths.active);
   } catch (cause) {
     if (hasCode(cause, "ENOENT")) return null;
     throw cause;
@@ -4810,13 +5919,20 @@ var readActive = (paths) => {
       "Server active pointer is invalid. Restore the symlink to a retained generation before retrying."
     );
   }
-  const directory = path12.join(paths.configDir, target);
+  const directory = path15.join(paths.configDir, target);
+  const optional = (key) => readOptional(path15.join(directory, fileNames[key])) ?? void 0;
+  const posture = optional("posture");
+  const edge = optional("edge");
+  const caddyfile = optional("caddyfile");
   const files = {
-    identity: fs12.readFileSync(path12.join(directory, fileNames.identity), "utf8"),
-    config: fs12.readFileSync(path12.join(directory, fileNames.config), "utf8"),
-    env: fs12.readFileSync(path12.join(directory, fileNames.env), "utf8"),
-    compose: fs12.readFileSync(path12.join(directory, fileNames.compose), "utf8"),
-    postgresInit: fs12.readFileSync(path12.join(directory, fileNames.postgresInit), "utf8")
+    identity: fs14.readFileSync(path15.join(directory, fileNames.identity), "utf8"),
+    config: fs14.readFileSync(path15.join(directory, fileNames.config), "utf8"),
+    env: fs14.readFileSync(path15.join(directory, fileNames.env), "utf8"),
+    compose: fs14.readFileSync(path15.join(directory, fileNames.compose), "utf8"),
+    postgresInit: fs14.readFileSync(path15.join(directory, fileNames.postgresInit), "utf8"),
+    ...posture === void 0 ? {} : { posture },
+    ...edge === void 0 ? {} : { edge },
+    ...caddyfile === void 0 ? {} : { caddyfile }
   };
   if (readIdentity(paths) !== files.identity) {
     throw new ServerStoreError(
@@ -4826,23 +5942,20 @@ var readActive = (paths) => {
   return { directory, files };
 };
 var publishIdentity = (paths, identity) => {
-  const temporary = path12.join(paths.configDir, `.identity-${randomUUID()}`);
+  const temporary = path15.join(paths.configDir, `.identity-${randomUUID2()}`);
   writeDurable(temporary, identity);
-  fs12.linkSync(temporary, paths.identity);
+  fs14.linkSync(temporary, paths.identity);
   syncDirectory(paths.configDir);
-  fs12.unlinkSync(temporary);
+  fs14.unlinkSync(temporary);
 };
 var prepareGeneration = (paths, files) => {
-  fs12.mkdirSync(paths.generations, { recursive: true, mode: 448 });
-  const generationName = `gen-${randomUUID()}`;
-  const directory = path12.join(paths.generations, generationName);
-  fs12.mkdirSync(directory, { mode: 448 });
-  for (const key of fileKeys) {
-    writeDurable(
-      path12.join(directory, fileNames[key]),
-      files[key],
-      key === "postgresInit" ? 493 : 384
-    );
+  fs14.mkdirSync(paths.generations, { recursive: true, mode: 448 });
+  const generationName = `gen-${randomUUID2()}`;
+  const directory = path15.join(paths.generations, generationName);
+  fs14.mkdirSync(directory, { mode: 448 });
+  for (const [key, content] of allFiles(files)) {
+    if (content === void 0) continue;
+    writeDurable(path15.join(directory, fileNames[key]), content, fileModes[key]);
   }
   syncDirectory(directory);
   syncDirectory(paths.generations);
@@ -4850,18 +5963,18 @@ var prepareGeneration = (paths, files) => {
   return { directory, files };
 };
 var activateGeneration = (paths, generation) => {
-  const relative4 = path12.relative(paths.configDir, generation.directory);
-  if (!/^generations\/gen-[0-9a-f-]{36}$/.test(relative4) || readIdentity(paths) !== fs12.readFileSync(path12.join(generation.directory, "identity.env"), "utf8")) {
+  const relative5 = path15.relative(paths.configDir, generation.directory);
+  if (!/^generations\/gen-[0-9a-f-]{36}$/.test(relative5) || readIdentity(paths) !== fs14.readFileSync(path15.join(generation.directory, "identity.env"), "utf8")) {
     throw new ServerStoreError("Cannot activate a generation outside this installation identity.");
   }
-  for (const key of fileKeys) {
-    if (fs12.readFileSync(path12.join(generation.directory, fileNames[key]), "utf8") !== generation.files[key]) {
+  for (const [key, content] of allFiles(generation.files)) {
+    if (readOptional(path15.join(generation.directory, fileNames[key])) !== (content ?? null)) {
       throw new ServerStoreError("Cannot activate an incomplete or changed server generation.");
     }
   }
-  const pointer = path12.join(paths.configDir, `.active-${randomUUID()}`);
-  fs12.symlinkSync(relative4, pointer);
-  fs12.renameSync(pointer, paths.active);
+  const pointer = path15.join(paths.configDir, `.active-${randomUUID2()}`);
+  fs14.symlinkSync(relative5, pointer);
+  fs14.renameSync(pointer, paths.active);
   syncDirectory(paths.configDir);
 };
 var prepareFiles = (paths, files) => {
@@ -4870,7 +5983,7 @@ var prepareFiles = (paths, files) => {
     throw new ServerStoreError("Server identity already exists; refusing to replace credentials.");
   }
   const active = readActive(paths);
-  if (active !== null && fileKeys.every((key) => files[key] === active.files[key]) && (fs12.statSync(path12.join(active.directory, fileNames.postgresInit)).mode & 4095) === 493)
+  if (active !== null && allFiles(files).every(([key, content]) => content === active.files[key]) && (fs14.statSync(path15.join(active.directory, fileNames.postgresInit)).mode & 4095) === 493)
     return active;
   if (identity === null) publishIdentity(paths, files.identity);
   return prepareGeneration(paths, files);
@@ -4883,9 +5996,9 @@ var commitGeneration = (paths, files) => {
 var createStore = (configDir, lock) => {
   const paths = {
     configDir,
-    identity: path12.join(configDir, "identity.env"),
-    generations: path12.join(configDir, "generations"),
-    active: path12.join(configDir, "active")
+    identity: path15.join(configDir, "identity.env"),
+    generations: path15.join(configDir, "generations"),
+    active: path15.join(configDir, "active")
   };
   const whileOwned = (operation) => attempt(() => {
     lock.assertOwned();
@@ -4898,13 +6011,13 @@ var createStore = (configDir, lock) => {
     prepare: (files) => whileOwned(() => prepareFiles(paths, files)),
     activate: (generation) => whileOwned(() => activateGeneration(paths, generation)),
     createBackup: (previous, target) => whileOwned(() => {
-      const backups = path12.join(configDir, "backups");
-      fs12.mkdirSync(backups, { recursive: true, mode: 448 });
-      fs12.chmodSync(backups, 448);
-      const directory = path12.join(backups, `upgrade-${randomUUID()}`);
-      fs12.mkdirSync(directory, { mode: 448 });
+      const backups = path15.join(configDir, "backups");
+      fs14.mkdirSync(backups, { recursive: true, mode: 448 });
+      fs14.chmodSync(backups, 448);
+      const directory = path15.join(backups, `upgrade-${randomUUID2()}`);
+      fs14.mkdirSync(directory, { mode: 448 });
       writeDurable(
-        path12.join(directory, "recovery.json"),
+        path15.join(directory, "recovery.json"),
         `${JSON.stringify(
           {
             previousGeneration: previous.directory,
@@ -4920,21 +6033,21 @@ var createStore = (configDir, lock) => {
       syncDirectory(directory);
       syncDirectory(backups);
       syncDirectory(configDir);
-      const partialFile = path12.join(directory, "database.sql.partial");
+      const partialFile = path15.join(directory, "database.sql.partial");
       return {
         directory,
         partialFile,
         complete: () => whileOwned(() => {
-          if (fs12.statSync(partialFile).size === 0)
+          if (fs14.statSync(partialFile).size === 0)
             throw new ServerStoreError("Database backup is empty; refusing target startup.");
-          const fd = fs12.openSync(partialFile, "r");
+          const fd = fs14.openSync(partialFile, "r");
           try {
-            fs12.fchmodSync(fd, 384);
-            fs12.fsyncSync(fd);
+            fs14.fchmodSync(fd, 384);
+            fs14.fsyncSync(fd);
           } finally {
-            fs12.closeSync(fd);
+            fs14.closeSync(fd);
           }
-          fs12.renameSync(partialFile, path12.join(directory, "database.sql"));
+          fs14.renameSync(partialFile, path15.join(directory, "database.sql"));
           syncDirectory(directory);
         })
       };
@@ -4943,7 +6056,7 @@ var createStore = (configDir, lock) => {
 };
 var refuseFlatLayout = (configDir) => {
   if (["server.json", "server.env", "compose.yaml", "postgres-init.sh"].some(
-    (name) => fs12.existsSync(path12.join(configDir, name))
+    (name) => fs14.existsSync(path15.join(configDir, name))
   )) {
     throw new ServerStoreError(
       "Unreleased flat server configuration found. Preserve its credentials and volumes; migrate it to the generation layout before retrying. Setup will not replace this identity."
@@ -4951,7 +6064,7 @@ var refuseFlatLayout = (configDir) => {
   }
 };
 var withServerStore = async (directory, operation, options = {}) => {
-  const configDir = path12.resolve(directory);
+  const configDir = path15.resolve(directory);
   let lock;
   let result;
   try {
@@ -4968,9 +6081,9 @@ var withServerStore = async (directory, operation, options = {}) => {
 };
 
 // src/version.ts
-import * as fs13 from "node:fs";
+import * as fs15 from "node:fs";
 var cliVersion = () => {
-  const raw = fs13.readFileSync(new URL("../package.json", import.meta.url), "utf8");
+  const raw = fs15.readFileSync(new URL("../package.json", import.meta.url), "utf8");
   const parsed = JSON.parse(raw);
   if (typeof parsed === "object" && parsed !== null && "version" in parsed) {
     const version = parsed.version;
@@ -5079,8 +6192,31 @@ var SETUP_FLAGS = /* @__PURE__ */ new Set([
   "--ssh-port",
   "--docker-socket",
   "--assets-dir",
-  "--offline"
+  "--offline",
+  "--edge",
+  "--no-edge",
+  "--exposure",
+  "--tenancy"
 ]);
+var parseExposure = (value) => {
+  if (!isExposure(value))
+    throw setupError(`--exposure must be one of ${EXPOSURES.join(", ")}, not "${value}".`);
+  return value;
+};
+var parseTenancy = (value) => {
+  if (!isTenancy(value))
+    throw setupError(`--tenancy must be one of ${TENANCIES.join(", ")}, not "${value}".`);
+  return value;
+};
+var parseEdge = (value) => {
+  const host = parseEdgeHost(value);
+  if (host === null) {
+    throw setupError(
+      `--edge must be a DNS name a certificate can be issued for, such as mend.example.com, not "${value}". An IP address or a single label cannot carry a public certificate.`
+    );
+  }
+  return host;
+};
 var parseSetupOptions = (args) => {
   const values = /* @__PURE__ */ new Map();
   for (let index = 0; index < args.length; index += 1) {
@@ -5088,8 +6224,8 @@ var parseSetupOptions = (args) => {
     if (flag === void 0) continue;
     if (!flag.startsWith("--")) throw setupError(`Unexpected server setup argument "${flag}".`);
     if (!SETUP_FLAGS.has(flag)) throw setupError(`Unknown server setup option "${flag}".`);
-    if (flag === "--offline") {
-      if (values.has(flag)) throw setupError("--offline may be supplied only once.");
+    if (flag === "--offline" || flag === "--no-edge") {
+      if (values.has(flag)) throw setupError(`${flag} may be supplied only once.`);
       values.set(flag, ["true"]);
       continue;
     }
@@ -5107,6 +6243,11 @@ var parseSetupOptions = (args) => {
   const appPort = flagValue3("--port");
   const sshPort = flagValue3("--ssh-port");
   const origins = values.get("--origin");
+  const edge = flagValue3("--edge");
+  const exposure = flagValue3("--exposure");
+  const tenancy = flagValue3("--tenancy");
+  if (edge !== void 0 && values.has("--no-edge"))
+    throw setupError("--edge and --no-edge contradict each other.");
   return {
     context: flagValue3("--context"),
     version: version === void 0 ? void 0 : parseVersion(version),
@@ -5117,7 +6258,11 @@ var parseSetupOptions = (args) => {
     sshPort: sshPort === void 0 ? void 0 : parsePort(sshPort, "--ssh-port"),
     dockerSocket: flagValue3("--docker-socket"),
     assetsDir: flagValue3("--assets-dir"),
-    offline: values.has("--offline")
+    offline: values.has("--offline"),
+    edge: edge === void 0 ? void 0 : parseEdge(edge),
+    noEdge: values.has("--no-edge"),
+    exposure: exposure === void 0 ? void 0 : parseExposure(exposure),
+    tenancy: tenancy === void 0 ? void 0 : parseTenancy(tenancy)
   };
 };
 var parseUrl = (input, label) => {
@@ -5140,11 +6285,20 @@ var parseHttpOrigin = (input, label) => {
   return parsed.origin;
 };
 var isLoopbackBind = (bind) => bind === "127.0.0.1" || bind === "::1" || bind.startsWith("127.");
-var isLoopbackHost = (hostname7) => hostname7 === "localhost" || hostname7 === "::1" || hostname7 === "[::1]" || hostname7.startsWith("127.");
-var resolveAppUrl = (existing, options, appPort) => {
+var isLoopbackHost = (hostname8) => hostname8 === "localhost" || hostname8 === "::1" || hostname8 === "[::1]" || hostname8.startsWith("127.");
+var resolveAppUrl = (existing, options, appPort, edgeHost) => {
+  if (edgeHost !== void 0) {
+    const origin = parseHttpOrigin(options.url ?? `https://${edgeHost}`, "--url");
+    if (origin !== `https://${edgeHost}`) {
+      throw setupError(
+        `With --edge ${edgeHost}, --url must be https://${edgeHost}, the origin the edge serves.`
+      );
+    }
+    return origin;
+  }
   const oldLocalUrl = existing === null ? null : `http://localhost:${existing.appPort}`;
   const portChangedOnLocalhost = options.appPort !== void 0 && existing?.appUrl === oldLocalUrl;
-  const fallback = portChangedOnLocalhost ? `http://localhost:${appPort}` : existing?.appUrl ?? `http://localhost:${appPort}`;
+  const fallback = portChangedOnLocalhost || existing?.edgeHost !== void 0 ? `http://localhost:${appPort}` : existing?.appUrl ?? `http://localhost:${appPort}`;
   return parseHttpOrigin(options.url ?? fallback, "--url");
 };
 var checkExposurePair = (bind, appUrl, requireExplicitUrl) => {
@@ -5159,6 +6313,33 @@ var checkExposurePair = (bind, appUrl, requireExplicitUrl) => {
     );
   }
 };
+var checkPosture = (bind, ports, edgeHost, exposure) => {
+  if (edgeHost !== void 0 && [ports.appPort, ports.sshPort].some((p) => p === 80 || p === 443)) {
+    throw setupError(
+      "With an edge, --port and --ssh-port must not be 80 or 443: the edge publishes both on every interface."
+    );
+  }
+  if (edgeHost !== void 0 && !isLoopbackBind(bind)) {
+    throw setupError(
+      `With an edge, --bind stays on loopback, ${DEFAULT_BIND}: the edge publishes 80 and 443, and Mend's own port is reached through it alone.`
+    );
+  }
+  if (edgeHost !== void 0 && exposure === "loopback") {
+    throw setupError(
+      "--exposure loopback and an edge contradict each other: the edge publishes 80 and 443 on every interface."
+    );
+  }
+  if (exposure === "loopback" && !isLoopbackBind(bind)) {
+    throw setupError(
+      "--exposure loopback contradicts a non-loopback --bind: the port is published beyond this machine."
+    );
+  }
+  if (exposure === "public" && edgeHost === void 0) {
+    throw setupError(
+      "--exposure public needs the edge: add --edge <host>. Without it nothing sets MEND_TRUSTED_PROXIES or an https origin, and the server refuses to start as public."
+    );
+  }
+};
 var validateExposure = (existing, options) => {
   const appPort = options.appPort ?? existing?.appPort ?? DEFAULT_APP_PORT;
   const sshPort = options.sshPort ?? existing?.sshPort ?? DEFAULT_SSH_PORT;
@@ -5166,19 +6347,33 @@ var validateExposure = (existing, options) => {
     throw setupError("--port and --ssh-port must use different ports.");
   }
   const bind = options.bind ?? existing?.bind ?? DEFAULT_BIND;
-  if (net2.isIP(bind) === 0) {
+  if (net3.isIP(bind) === 0) {
     throw setupError(
       "--bind must be a literal IPv4 or IPv6 address, such as 127.0.0.1 or 0.0.0.0."
     );
   }
-  const appUrl = resolveAppUrl(existing, options, appPort);
-  checkExposurePair(bind, appUrl, options.url === void 0 && existing === null);
+  const edgeHost = options.noEdge ? void 0 : options.edge ?? existing?.edgeHost;
+  const exposure = options.exposure ?? existing?.exposure;
+  const tenancy = options.tenancy ?? existing?.tenancy;
+  checkPosture(bind, { appPort, sshPort }, edgeHost, exposure);
+  const appUrl = resolveAppUrl(existing, options, appPort, edgeHost);
+  if (edgeHost === void 0)
+    checkExposurePair(bind, appUrl, options.url === void 0 && existing === null);
   const requestedOrigins = options.origins?.map((origin) => parseHttpOrigin(origin, "--origin"));
   const inheritedOrigins = existing?.allowedOrigins ?? [];
   const allowedOrigins = [
     ...new Set((requestedOrigins ?? inheritedOrigins).filter((origin) => origin !== appUrl))
   ];
-  return { bind, appUrl, allowedOrigins, appPort, sshPort };
+  return {
+    bind,
+    appUrl,
+    allowedOrigins,
+    appPort,
+    sshPort,
+    ...edgeHost === void 0 ? {} : { edgeHost },
+    ...exposure === void 0 ? {} : { exposure },
+    ...tenancy === void 0 ? {} : { tenancy }
+  };
 };
 var parseServerConfig = (raw) => {
   let decoded;
@@ -5204,6 +6399,18 @@ var parseServerConfig = (raw) => {
   if (dockerSocketSource !== "detected" && dockerSocketSource !== "override") {
     throw setupError("Server config is corrupt: dockerSocketSource must be detected or override.");
   }
+  const edgeHost = fields.has("edgeHost") ? requiredString(fields, "edgeHost") : void 0;
+  if (edgeHost !== void 0 && parseEdgeHost(edgeHost) !== edgeHost) {
+    throw setupError("Server config is corrupt: edgeHost must be a lowercase DNS name.");
+  }
+  const exposure = fields.has("exposure") ? requiredString(fields, "exposure") : void 0;
+  if (exposure !== void 0 && !isExposure(exposure)) {
+    throw setupError(`Server config is corrupt: exposure must be one of ${EXPOSURES.join(", ")}.`);
+  }
+  const tenancy = fields.has("tenancy") ? requiredString(fields, "tenancy") : void 0;
+  if (tenancy !== void 0 && !isTenancy(tenancy)) {
+    throw setupError(`Server config is corrupt: tenancy must be one of ${TENANCIES.join(", ")}.`);
+  }
   const config = {
     schemaVersion: requiredInteger(fields, "schemaVersion"),
     assetContract: requiredString(fields, "assetContract"),
@@ -5220,7 +6427,10 @@ var parseServerConfig = (raw) => {
     appPort: requiredInteger(fields, "appPort"),
     sshPort: requiredInteger(fields, "sshPort"),
     ...fields.has("registryPort") ? { registryPort: requiredInteger(fields, "registryPort") } : {},
-    ...fields.has("bucket") ? { bucket: requiredBucket(fields) } : {}
+    ...fields.has("bucket") ? { bucket: requiredBucket(fields) } : {},
+    ...edgeHost === void 0 ? {} : { edgeHost },
+    ...exposure === void 0 ? {} : { exposure },
+    ...tenancy === void 0 ? {} : { tenancy }
   };
   if (config.schemaVersion !== CONFIG_SCHEMA_VERSION || config.assetContract !== ASSET_CONTRACT && !LEGACY_ASSET_CONTRACTS.has(config.assetContract)) {
     throw setupError(
@@ -5241,7 +6451,11 @@ var parseServerConfig = (raw) => {
     sshPort: config.sshPort,
     dockerSocket: void 0,
     assetsDir: void 0,
-    offline: false
+    offline: false,
+    edge: config.edgeHost,
+    noEdge: false,
+    exposure: config.exposure,
+    tenancy: config.tenancy
   });
   return config;
 };
@@ -5334,10 +6548,8 @@ var parseContextRows = (raw) => {
   return rows;
 };
 var localUnixEndpoint = (endpoint) => endpoint.startsWith("unix:///");
-var commandFailure = (label, output) => {
-  const detail = output.stderr.trim() || output.error || `exit ${output.status ?? "unknown"}`;
-  return setupError(`${label}: ${detail}`);
-};
+var outputDetail = (output) => output.stderr.trim() || output.error || `exit ${output.status ?? "unknown"}`;
+var commandFailure = (label, output) => setupError(`${label}: ${outputDetail(output)}`);
 var selectDockerContext = async (runtime, requested) => {
   if (requested !== void 0) {
     const inspect = await runtime.run("docker", [
@@ -5420,6 +6632,32 @@ var checkDocker = async (runtime, context) => {
   }
   return info.stdout.trim();
 };
+var hostUserNamespacesLine = async (runtime, context, image) => {
+  const read = HOST_USER_NAMESPACE_FILES.map(
+    (file) => `printf '%s|' "$(cat ${file} 2>/dev/null || echo -)"`
+  ).join("; ");
+  const probe = await runtime.run("docker", [
+    "--context",
+    context,
+    "run",
+    "--rm",
+    "--network",
+    "none",
+    "--entrypoint",
+    "sh",
+    image,
+    "-c",
+    read
+  ]);
+  if (probe.status !== 0) return null;
+  const [restrict, apparmor, clone] = probe.stdout.trim().split("|").map((value) => value.trim() === "-" ? null : value);
+  const observed = hostUserNamespacesOf({
+    apparmorRestrictUnprivilegedUserns: restrict ?? null,
+    apparmorEnabled: apparmor ?? null,
+    unprivilegedUsernsClone: clone ?? null
+  });
+  return observed.allowed ? null : `No session can start on this Docker host yet: its kernel refuses unprivileged user namespaces, which each workspace's rootless Docker service needs. On the host, run: ${hostUserNamespacesFix(observed.setting)}`;
+};
 var resolveLatestVersion = async (runtime) => {
   runtime.writeLine("Resolving the latest Mend server release");
   const response = await runtime.fetchText(LATEST_RELEASE_URL, 15e3);
@@ -5556,7 +6794,7 @@ var renderGarage = (secrets, config) => {
 var namespaceOf = (config) => config.bucket === "garage" ? MEND_DOCKER_NAMESPACE_WITH_GARAGE : MEND_DOCKER_NAMESPACE;
 var renderSecrets = (secrets, config) => {
   const sshHost = parseUrl(config.appUrl, "Server config appUrl").hostname.replace(/^\[|\]$/g, "");
-  const composeBind = net2.isIP(config.bind) === 6 ? `[${config.bind}]` : config.bind;
+  const composeBind = net3.isIP(config.bind) === 6 ? `[${config.bind}]` : config.bind;
   return [
     `MEND_VERSION=${config.serverVersion}`,
     "MEND_IMAGE_REPOSITORY=ghcr.io/sealant-sh/mend",
@@ -5568,6 +6806,9 @@ var renderSecrets = (secrets, config) => {
     `MEND_SSH_PORT=${config.sshPort}`,
     ...config.registryPort === void 0 ? [] : [`MEND_REGISTRY_PORT=${config.registryPort}`],
     `SEALANT_SSH_HOST=${sshHost}`,
+    // The edge's host and the posture (server-edge.ts): compose.edge.yaml and
+    // compose.posture.yaml read them from here, and only from here.
+    ...postureEnvLines(config),
     "MEND_STORE_VOLUME_NAME=mend-store",
     "MEND_CONTROL_VOLUME_NAME=mend-control",
     ...renderGarage(secrets, config),
@@ -5579,6 +6820,48 @@ var storeValue = (result) => {
   if (result._tag === "error") throw result.error;
   return result.value;
 };
+var composeTarget = (installation) => ({
+  directory: installation.directory,
+  dockerContext: installation.config.dockerContext,
+  overlays: composeOverlays(installation.config)
+});
+var edgeImageOf = (overlay) => {
+  const image = /^ {4}image:[ \t]*(caddy:[^\s#]+)[ \t]*$/m.exec(overlay)?.[1];
+  if (image === void 0)
+    throw setupError("Server generation is corrupt: compose.edge.yaml pins no Caddy image.");
+  return image;
+};
+var validateOverlays = (config, files) => {
+  const posture = renderPostureOverlay(config);
+  if (posture === void 0 !== (files.posture === void 0)) {
+    throw setupError(
+      "Server generation is corrupt: compose.posture.yaml does not match the persisted server config."
+    );
+  }
+  for (const line of postureEnvLines(config)) {
+    const key = line.slice(0, line.indexOf("="));
+    if (key !== "MEND_EDGE_HOST" && !(files.posture ?? "").includes(`      ${key}: \${${key}`)) {
+      throw setupError(
+        `Server generation is corrupt: compose.posture.yaml does not hand ${key} to Mend.`
+      );
+    }
+  }
+  if (config.edgeHost === void 0 !== (files.edge === void 0) || config.edgeHost === void 0 !== (files.caddyfile === void 0)) {
+    throw setupError(
+      "Server generation is corrupt: compose.edge.yaml and Caddyfile do not match the persisted server config."
+    );
+  }
+  if (files.edge === void 0 || files.caddyfile === void 0) return void 0;
+  if (!files.edge.includes("\n  edge:") || !files.edge.includes("MEND_EDGE_HOST") || !files.edge.includes("./Caddyfile:/etc/caddy/Caddyfile")) {
+    throw setupError("Server generation is corrupt: compose.edge.yaml is not the edge overlay.");
+  }
+  if (!files.caddyfile.includes("{$MEND_EDGE_HOST}") || !files.caddyfile.includes("reverse_proxy mend:3105")) {
+    throw setupError(
+      "Server generation is corrupt: the Caddyfile does not route the edge host to Mend."
+    );
+  }
+  return edgeImageOf(files.edge);
+};
 var readServerInstallation = (store) => {
   try {
     const generation = storeValue(store.readActive());
@@ -5592,7 +6875,15 @@ var readServerInstallation = (store) => {
     }
     validateComposeAsset(generation.files.compose);
     validatePostgresAsset(generation.files.postgresInit);
-    return { _tag: "ok", value: { config, directory: generation.directory } };
+    const edgeImage = validateOverlays(config, generation.files);
+    return {
+      _tag: "ok",
+      value: {
+        config,
+        directory: generation.directory,
+        ...edgeImage === void 0 ? {} : { edgeImage }
+      }
+    };
   } catch (cause) {
     return {
       _tag: "error",
@@ -5618,6 +6909,11 @@ var readServerInstallationFacts = async (configDir) => {
         directory: installation.directory,
         config: installation.config,
         compose: generation.files.compose,
+        overlays: [
+          ...generation.files.edge === void 0 ? [] : [{ name: "compose.edge.yaml", content: generation.files.edge }],
+          ...generation.files.caddyfile === void 0 ? [] : [{ name: "Caddyfile", content: generation.files.caddyfile }],
+          ...generation.files.posture === void 0 ? [] : [{ name: "compose.posture.yaml", content: generation.files.posture }]
+        ],
         envKeys: envKeyNames(generation.files.env)
       };
     },
@@ -5626,15 +6922,25 @@ var readServerInstallationFacts = async (configDir) => {
   if (result._tag === "error") throw result.error;
   return result.value;
 };
-var persistSetup = (store, config, secrets, assets) => storeValue(
-  store.prepare({
-    identity: renderIdentity(secrets),
+var generationFiles = (config, secrets, assets, identity = renderIdentity(secrets)) => {
+  const posture = renderPostureOverlay(config);
+  return {
+    identity,
     config: `${JSON.stringify(config, null, 2)}
 `,
     env: renderSecrets(secrets, config),
-    ...assets
-  })
-);
+    ...assets,
+    ...posture === void 0 ? {} : { posture },
+    ...config.edgeHost === void 0 ? {} : { edge: EDGE_COMPOSE_OVERLAY, caddyfile: EDGE_CADDYFILE }
+  };
+};
+var persistSetup = (store, config, secrets, assets) => storeValue(store.prepare(generationFiles(config, secrets, assets)));
+var healthOrigin = (config) => {
+  if (config.edgeHost === void 0) return config.appUrl;
+  const host = net3.isIP(config.bind) === 6 ? `[${config.bind}]` : config.bind;
+  return `http://${host}:${config.appPort}`;
+};
+var reachableLine = (config) => config.edgeHost === void 0 ? `Mend ${config.serverVersion} is reachable at ${config.appUrl}` : `Mend ${config.serverVersion} answers at ${healthOrigin(config)} on this machine \xB7 the edge is set up for ${config.appUrl}`;
 var probeHealth = async (runtime, appUrl, expectedVersion) => {
   const healthUrl = `${appUrl}/api/health`;
   let lastFailure = "request did not complete";
@@ -5673,7 +6979,7 @@ var resolveServerVersion = async (runtime, options, existing) => {
   return version;
 };
 var parseDockerSocketPath = (socket) => {
-  if (!path13.isAbsolute(socket) || /[\r\n$'"#:\\]/.test(socket)) {
+  if (!path16.isAbsolute(socket) || /[\r\n$'"#:\\]/.test(socket)) {
     throw setupError(
       "--docker-socket must be an absolute path without line breaks or Compose interpolation characters."
     );
@@ -5699,8 +7005,8 @@ var resolveAssets = async (runtime, serverVersion, existing, store, options) =>
   if (options.assetsDir !== void 0) {
     try {
       const [compose2, postgresInit2] = await Promise.all([
-        readFile(path13.join(options.assetsDir, COMPOSE_ASSET), "utf8"),
-        readFile(path13.join(options.assetsDir, POSTGRES_INIT_ASSET), "utf8")
+        readFile(path16.join(options.assetsDir, COMPOSE_ASSET), "utf8"),
+        readFile(path16.join(options.assetsDir, POSTGRES_INIT_ASSET), "utf8")
       ]);
       validateComposeAsset(compose2);
       validatePostgresAsset(postgresInit2);
@@ -5740,7 +7046,8 @@ var inspectImage = async (runtime, context, image, format, policy) => {
   if (pulled.status !== 0) throw commandFailure(`Could not pull ${image}`, pulled);
   return runtime.run("docker", args);
 };
-var checkLocalImages = async (runtime, config, policy = "local") => {
+var checkLocalImages = async (runtime, installation, policy = "local") => {
+  const { config } = installation;
   const image = `ghcr.io/sealant-sh/mend:${config.serverVersion}`;
   const mend = await inspectImage(
     runtime,
@@ -5775,25 +7082,34 @@ var checkLocalImages = async (runtime, config, policy = "local") => {
     if (garage.status !== 0)
       throw commandFailure(`Preload ${GARAGE_IMAGE} before continuing`, garage);
   }
+  if (installation.edgeImage !== void 0) {
+    const edge = await inspectImage(
+      runtime,
+      config.dockerContext,
+      installation.edgeImage,
+      "{{.Id}}",
+      policy
+    );
+    if (edge.status !== 0)
+      throw commandFailure(`Preload ${installation.edgeImage} before continuing`, edge);
+  }
 };
 var checkComposeImages = async (runtime, installation) => {
   const output = await runtime.run(
     "docker",
-    serverComposeArgs(
-      { directory: installation.directory, dockerContext: installation.config.dockerContext },
-      ["config", "--images"]
-    )
+    serverComposeArgs(composeTarget(installation), ["config", "--images"])
   );
   if (output.status !== 0) throw commandFailure("Docker Compose config failed", output);
   const images = output.stdout.trim().split(/\s+/).toSorted();
   const expected = [
     `ghcr.io/sealant-sh/mend:${installation.config.serverVersion}`,
     "postgres:17-alpine",
-    ...installation.config.bucket === "garage" ? [GARAGE_IMAGE] : []
+    ...installation.config.bucket === "garage" ? [GARAGE_IMAGE] : [],
+    ...installation.edgeImage === void 0 ? [] : [installation.edgeImage]
   ].toSorted();
   if (images.join("\n") !== expected.join("\n")) {
     throw setupError(
-      `Compose must use only the canonical pinned Mend image, official postgres:17-alpine${installation.config.bucket === "garage" ? ` and ${GARAGE_IMAGE}` : ""}.`
+      `Compose must use only the canonical pinned Mend image, official postgres:17-alpine${installation.config.bucket === "garage" ? ` and ${GARAGE_IMAGE}` : ""}${installation.edgeImage === void 0 ? "" : ` and the edge's ${installation.edgeImage}`}.`
     );
   }
 };
@@ -5802,10 +7118,15 @@ var initGarage = async (runtime, installation, secrets) => {
   const garage = garageSecrets(secrets);
   const exec = (args) => runtime.run(
     "docker",
-    serverComposeArgs(
-      { directory: installation.directory, dockerContext: installation.config.dockerContext },
-      ["exec", "-T", "garage", "/garage", "-c", "/etc/garage.toml", ...args]
-    ),
+    serverComposeArgs(composeTarget(installation), [
+      "exec",
+      "-T",
+      "garage",
+      "/garage",
+      "-c",
+      "/etc/garage.toml",
+      ...args
+    ]),
     { timeoutMs: serverProcessDeadlines.ordinary }
   );
   const status = await exec(["status"]);
@@ -5827,19 +7148,79 @@ var initGarage = async (runtime, installation, secrets) => {
     "--key",
     GARAGE_BUCKET
   ]);
-  const info = await exec(["bucket", "info", GARAGE_BUCKET]);
-  if (info.status !== 0 || info.error !== void 0 || !info.stdout.includes(garage.keyId))
-    throw commandFailure(`Garage bucket ${GARAGE_BUCKET} is not readable by Mend's key`, info);
-  runtime.writeLine(`Capture store bucket ${GARAGE_BUCKET} is laid out in Garage`);
+  const info = await exec(["bucket", "info", GARAGE_BUCKET]);
+  if (info.status !== 0 || info.error !== void 0 || !info.stdout.includes(garage.keyId))
+    throw commandFailure(`Garage bucket ${GARAGE_BUCKET} is not readable by Mend's key`, info);
+  runtime.writeLine(`Capture store bucket ${GARAGE_BUCKET} is laid out in Garage`);
+};
+var startingNotice = (runtime, version) => runtime.writeLine(
+  `Starting Mend ${version} containers; Docker waits up to ${serverProcessDeadlines.composeWaitSeconds}s for them to report healthy`
+);
+var removeStrayEdge = async (runtime, installation) => {
+  if (installation.config.edgeHost !== void 0) return;
+  const context = installation.config.dockerContext;
+  const listed = await runtime.run("docker", [
+    "--context",
+    context,
+    "container",
+    "ls",
+    "--all",
+    "--filter",
+    "label=com.docker.compose.project=mend",
+    "--filter",
+    "label=com.docker.compose.service=edge",
+    "--format",
+    '{{.Names}}	{{.Label "com.docker.compose.project.working_dir"}}'
+  ]);
+  if (listed.status !== 0 || listed.error !== void 0) {
+    runtime.writeLine(
+      `Could not list this project's containers: ${outputDetail(listed)}. An edge container left by an earlier generation, if any, stays until the next start. mend server status shows it.`
+    );
+    return;
+  }
+  const generations = path16.dirname(installation.directory);
+  let resolvedGenerations = generations;
+  try {
+    resolvedGenerations = fs16.realpathSync(generations);
+  } catch {
+    resolvedGenerations = generations;
+  }
+  const own = (workingDir) => [generations, resolvedGenerations].some((root) => workingDir.startsWith(`${root}${path16.sep}`));
+  const rows = listed.stdout.split("\n").map((line) => line.trim()).filter((line) => line !== "").map((line) => {
+    const [name = "", workingDir = ""] = line.split("	");
+    return { name, workingDir };
+  }).filter((row) => row.name !== "");
+  for (const row of rows.filter((candidate) => !own(candidate.workingDir))) {
+    runtime.writeLine(
+      `Edge container ${row.name} was started from ${row.workingDir || "an unknown directory"}, not from this installation's generations. It stays.`
+    );
+  }
+  const names = rows.filter((row) => own(row.workingDir)).map((row) => row.name);
+  if (names.length === 0) return;
+  const removed = await runtime.run("docker", [
+    "--context",
+    context,
+    "container",
+    "rm",
+    "--force",
+    ...names
+  ]);
+  if (removed.status !== 0 || removed.error !== void 0) {
+    runtime.writeLine(
+      `Could not remove the edge container ${names.join(", ")}: ${outputDetail(removed)}. It may still hold 80 and 443. To remove it: docker --context ${context} container rm --force ${names.join(" ")}`
+    );
+    return;
+  }
+  runtime.writeLine(
+    `Removed the edge container ${names.join(", ")}, which this generation does not run.`
+  );
 };
-var startingNotice = (runtime, version) => runtime.writeLine(
-  `Starting Mend ${version} containers; Docker waits up to ${serverProcessDeadlines.composeWaitSeconds}s for them to report healthy`
-);
-var startCompose = async (runtime, config, generation) => {
-  startingNotice(runtime, config.serverVersion);
+var startCompose = async (runtime, installation) => {
+  await removeStrayEdge(runtime, installation);
+  startingNotice(runtime, installation.config.serverVersion);
   const compose = await runtime.run(
     "docker",
-    serverComposeArgs({ directory: generation.directory, dockerContext: config.dockerContext }, [
+    serverComposeArgs(composeTarget(installation), [
       "up",
       "-d",
       "--wait",
@@ -5853,6 +7234,7 @@ var startCompose = async (runtime, config, generation) => {
   );
   if (compose.status !== 0) throw commandFailure("Mend containers did not start", compose);
 };
+var edgeStartedLine = (config) => config.edgeHost === void 0 ? null : `The edge for ${config.edgeHost} is up on 80 and 443. Caddy asks for its certificate once ${config.edgeHost} resolves to this machine and both ports reach it from the Internet. mend server status says whether it holds one, and mend server logs shows what Caddy tried.`;
 var setupServer = async (args, runtime, store) => {
   if (runtime.platform !== "linux" && runtime.platform !== "darwin") {
     throw setupError(`mend server setup supports Linux and macOS, not ${runtime.platform}.`);
@@ -5909,24 +7291,47 @@ var setupServer = async (args, runtime, store) => {
     ...configWithoutBucket,
     ...bucket === void 0 ? {} : { bucket }
   };
+  if (existing === null && (config.edgeHost !== void 0 || config.exposure === "public")) {
+    throw setupError(
+      `A fresh install cannot start with the edge or as public: until the first account exists, registration is open to whoever reaches the origin first, and the server refuses MEND_EXPOSURE=public without an operator account. Run mend server setup without --edge and --exposure public, create the first account at http://localhost:${config.appPort}, then run mend server setup --edge <host> and declare the posture.`
+    );
+  }
   const secrets = savedSecrets ?? createSecrets(runtime);
   const generation = persistSetup(store, config, secrets, assets);
-  await checkComposeImages(runtime, { directory: generation.directory, config });
+  const installation = {
+    directory: generation.directory,
+    config,
+    ...generation.files.edge === void 0 ? {} : { edgeImage: edgeImageOf(generation.files.edge) }
+  };
+  await checkComposeImages(runtime, installation);
   const ownership2 = await claimServerDockerVolumes(runtime, {
     dockerContext: config.dockerContext,
     identityBytes: Buffer.from(generation.files.identity),
     namespace: namespaceOf(config)
   });
   if (ownership2._tag === "error") throw setupError(ownership2.error.message);
-  await checkLocalImages(runtime, config, options.offline ? "local" : "pull-missing");
+  await checkLocalImages(runtime, installation, options.offline ? "local" : "pull-missing");
+  const userNamespaces = await hostUserNamespacesLine(
+    runtime,
+    config.dockerContext,
+    `ghcr.io/sealant-sh/mend:${config.serverVersion}`
+  );
   storeValue(store.activate(generation));
-  await startCompose(runtime, config, generation);
-  await initGarage(runtime, { directory: generation.directory, config }, secrets);
-  await probeHealth(runtime, config.appUrl, config.serverVersion);
-  runtime.writeLine(`Mend ${config.serverVersion} is reachable at ${config.appUrl}`);
+  await startCompose(runtime, installation);
+  await initGarage(runtime, installation, secrets);
+  await probeHealth(runtime, healthOrigin(config), config.serverVersion);
+  runtime.writeLine(reachableLine(config));
+  const edgeStarted = edgeStartedLine(config);
+  if (edgeStarted !== null) runtime.writeLine(edgeStarted);
+  if (existing?.config.edgeHost !== void 0 && config.edgeHost === void 0) {
+    runtime.writeLine(
+      `The edge for ${existing.config.edgeHost} is gone. Its certificate volumes stay until you remove them: docker --context ${config.dockerContext} volume rm mend_mend-edge-data mend_mend-edge-config`
+    );
+  }
   runtime.writeLine(
     `Open ${config.appUrl}, create the first account, then run: mend login --url ${config.appUrl}`
   );
+  if (userNamespaces !== null) runtime.writeLine(userNamespaces);
 };
 var serverVersionParts = (version) => {
   const separator = version.indexOf("-");
@@ -5970,7 +7375,7 @@ var composeCommand = async (runtime, installation, args) => {
   const output = await runtime.run(
     "docker",
     serverComposeArgs(
-      { directory: installation.directory, dockerContext: installation.config.dockerContext },
+      composeTarget(installation),
       args.flatMap(
         (arg) => arg === "--wait" ? [arg, "--wait-timeout", String(serverProcessDeadlines.composeWaitSeconds)] : [arg]
       )
@@ -5987,6 +7392,7 @@ var interruptionNotice = (runtime) => runtime.writeLine(
   "Connections will be interrupted. Workspace containers and data are retained, but active work can lose connectivity and may need reconnection. Mend does not stop workspace containers."
 );
 var startInstallation = async (runtime, installation, secrets) => {
+  await removeStrayEdge(runtime, installation);
   startingNotice(runtime, installation.config.serverVersion);
   await composeCommand(runtime, installation, [
     "up",
@@ -5997,33 +7403,160 @@ var startInstallation = async (runtime, installation, secrets) => {
     "--no-build"
   ]);
   await initGarage(runtime, installation, secrets);
-  await probeHealth(runtime, installation.config.appUrl, installation.config.serverVersion);
-  runtime.writeLine(
-    `Mend ${installation.config.serverVersion} is reachable at ${installation.config.appUrl}`
-  );
+  await probeHealth(runtime, healthOrigin(installation.config), installation.config.serverVersion);
+  runtime.writeLine(reachableLine(installation.config));
 };
 var parseUpgradeOptions = (args) => {
-  for (let index = 0; index < args.length; index += 1) {
-    const flag = args[index];
+  const fromPreview = args.includes("--from-preview");
+  const rest = args.filter((arg) => arg !== "--from-preview");
+  for (let index = 0; index < rest.length; index += 1) {
+    const flag = rest[index];
     if (flag === "--offline") continue;
     if (flag !== "--version" && flag !== "--assets-dir")
       throw setupError(`Unknown server upgrade option "${flag}".`);
     index += 1;
   }
-  const options = parseSetupOptions(args);
+  const options = parseSetupOptions(rest);
   if (options.version === void 0)
     throw setupError(
       "Upgrade requires --version TARGET. Use --version latest only to request the latest release explicitly."
     );
-  return options;
+  return { ...options, fromPreview };
+};
+var LEGACY_PREVIEW = /^(\d+\.\d+\.\d+)-preview\.(0|[1-9]\d*)$/;
+var NEXT_BUILD = /^(\d+\.\d+\.\d+)-next\.(0|[1-9]\d*)(\.preview\.[1-9]\d*)?$/;
+var isPreviewToNext = (from, to) => {
+  const preview = LEGACY_PREVIEW.exec(from);
+  const next = NEXT_BUILD.exec(to);
+  return preview !== null && next !== null && preview[1] === next[1];
+};
+var drizzleMillis = (folder) => {
+  const at = (start, end) => Number(folder.slice(start, end));
+  return String(Date.UTC(at(0, 4), at(4, 6) - 1, at(6, 8), at(8, 10), at(10, 12), at(12, 14)));
+};
+var mendKey = (migration) => `${String(migration.id).padStart(4, "0")}_${migration.name}`;
+var migrationProblems = (applied, manifest) => {
+  const mend = /* @__PURE__ */ new Map();
+  const sealant = /* @__PURE__ */ new Map();
+  const sealantTimes = /* @__PURE__ */ new Map();
+  for (const line of manifest.split("\n")) {
+    const [kind, entry, hash = ""] = line.trim().split(/\s+/);
+    if (entry === void 0) continue;
+    if (kind === "mend") {
+      const match = /^(\d+)_(.+)$/.exec(entry);
+      if (match?.[1] !== void 0 && match[2] !== void 0) mend.set(Number(match[1]), match[2]);
+    }
+    if (kind === "sealant") {
+      sealant.set(entry, hash);
+      sealantTimes.set(drizzleMillis(entry), hash);
+    }
+  }
+  const problems = [];
+  for (const migration of applied.mend) {
+    if (mend.get(migration.id) !== migration.name)
+      problems.push(`mend ${mendKey(migration)} is applied here and not in the target`);
+  }
+  const appliedIds = new Set(applied.mend.map((migration) => migration.id));
+  const highest = Math.max(0, ...appliedIds);
+  for (const [id, name] of [...mend].toSorted(([a], [b]) => a - b)) {
+    if (id <= highest && !appliedIds.has(id))
+      problems.push(
+        `mend ${mendKey({ id, name })} would never run: this server already applied ${highest}`
+      );
+  }
+  for (const row of applied.sealant) {
+    const label = row.name === "" ? `(created ${row.createdAt})` : row.name;
+    const hash = row.name === "" ? sealantTimes.get(row.createdAt) : sealant.get(row.name);
+    if (hash === void 0) problems.push(`sealant ${label} is applied here and not in the target`);
+    else if (hash !== row.hash)
+      problems.push(`sealant ${label} changed after this server applied it`);
+  }
+  return problems;
+};
+var psqlRows = async (runtime, installation, database, query) => {
+  const output = await composeCommand(runtime, installation, [
+    "exec",
+    "-T",
+    "postgres",
+    "psql",
+    "--username=postgres",
+    `--dbname=${database}`,
+    "--no-align",
+    "--tuples-only",
+    "--field-separator=|",
+    "--command",
+    query
+  ]);
+  return output.stdout.split("\n").filter((line) => line.trim().length > 0);
+};
+var checkPreviewMigrations = async (runtime, existing, target) => {
+  const image = `ghcr.io/sealant-sh/mend:${target.serverVersion}`;
+  const listed = await runtime.run(
+    "docker",
+    [
+      "--context",
+      target.dockerContext,
+      "run",
+      "--rm",
+      "--entrypoint",
+      "cat",
+      image,
+      "/app/migrations.txt"
+    ],
+    { timeoutMs: serverProcessDeadlines.ordinary }
+  );
+  if (listed.status !== 0 || listed.error !== void 0 || listed.stdout.trim() === "")
+    throw setupError(
+      `${image} does not list its migrations (/app/migrations.txt), so --from-preview cannot check them. Nothing was changed.`
+    );
+  await composeCommand(runtime, existing, [
+    "up",
+    "-d",
+    "--wait",
+    "--pull",
+    "never",
+    "--no-build",
+    "postgres"
+  ]);
+  const mend = (await psqlRows(
+    runtime,
+    existing,
+    "mend",
+    "select migration_id, name from mend_migrations order by migration_id"
+  )).map((line) => {
+    const [id = "", name = ""] = line.split("|");
+    return { id: Number(id), name };
+  });
+  const sealant = (await psqlRows(
+    runtime,
+    existing,
+    "sealant_control_plane",
+    "select coalesce(name, ''), created_at, hash from drizzle.__drizzle_migrations order by id"
+  )).map((line) => {
+    const [name = "", createdAt = "", hash = ""] = line.split("|");
+    return { name, createdAt, hash };
+  });
+  const problems = migrationProblems({ mend, sealant }, listed.stdout);
+  if (problems.length > 0)
+    throw setupError(
+      `${image} cannot take this server's databases (${problems.length}): ${problems.join("; ")}. Choose a build that contains every migration this server applied. Nothing was changed.`
+    );
+  runtime.writeLine(
+    `${image} carries all ${mend.length + sealant.length} migrations this server applied.`
+  );
 };
 var upgradeServer = async (args, runtime, store, existing) => {
   const options = parseUpgradeOptions(args);
   const version = await resolveServerVersion(runtime, options, existing.config);
   const order = compareServerVersions(version, existing.config.serverVersion);
-  if (order < 0)
+  const previewToNext = isPreviewToNext(existing.config.serverVersion, version);
+  if (options.fromPreview && !previewToNext)
+    throw setupError(
+      "--from-preview moves a server on X.Y.Z-preview.K to a next build or a new-style preview of the same version (X.Y.Z-next.N, X.Y.Z-next.N.preview.R), and nothing else."
+    );
+  if (order < 0 && !options.fromPreview)
     throw setupError(
-      `Refusing downgrade from ${existing.config.serverVersion} to ${version}. Database migrations may not be reversible.`
+      `Refusing downgrade from ${existing.config.serverVersion} to ${version}. Database migrations may not be reversible.${previewToNext ? ` ${existing.config.serverVersion} is a preview numbered before the next channel. To move to the next channel once, run mend server upgrade --version ${version} --from-preview; it first checks that ${version} carries every migration this server applied.` : ""}`
     );
   if (order === 0) {
     runtime.writeLine(
@@ -6047,20 +7580,20 @@ var upgradeServer = async (args, runtime, store, existing) => {
     ...bucket === void 0 ? {} : { bucket }
   };
   const secrets = parseSecrets(previous.files.identity);
-  const files = {
-    identity: previous.files.identity,
-    config: `${JSON.stringify(config, null, 2)}
-`,
-    env: renderSecrets(secrets, config),
-    ...assets
-  };
+  const files = generationFiles(config, secrets, assets, previous.files.identity);
   const parsed = parseServerConfig(files.config);
   if (renderSecrets(parseSecrets(files.env), parsed) !== files.env)
     throw setupError("Invalid upgrade configuration.");
-  await checkLocalImages(runtime, config, options.offline ? "local" : "pull-missing");
+  const edgeImage = files.edge === void 0 ? {} : { edgeImage: edgeImageOf(files.edge) };
+  await checkLocalImages(
+    runtime,
+    { config, ...edgeImage },
+    options.offline ? "local" : "pull-missing"
+  );
   await checkComposeImages(runtime, existing);
+  if (options.fromPreview) await checkPreviewMigrations(runtime, existing, config);
   const target = storeValue(store.prepare(files));
-  const installation = { directory: target.directory, config };
+  const installation = { directory: target.directory, config, ...edgeImage };
   await checkComposeImages(runtime, installation);
   if (config.bucket === "garage" && existing.config.bucket !== "garage") {
     const ownership2 = await claimServerDockerVolumes(runtime, {
@@ -6095,7 +7628,7 @@ var upgradeServer = async (args, runtime, store, existing) => {
     ]);
     const dumped = await runtime.run(
       "docker",
-      serverComposeArgs({ directory: previous.directory, dockerContext: config.dockerContext }, [
+      serverComposeArgs(composeTarget(existing), [
         "exec",
         "-T",
         "postgres",
@@ -6137,11 +7670,112 @@ var upgradeServer = async (args, runtime, store, existing) => {
   }
   runtime.writeLine(`Upgraded to ${version}. Retained database backup: ${backup.directory}`);
 };
-var serverStatus = async (runtime, installation) => {
-  runtime.writeLine(
-    `Pinned Mend ${installation.config.serverVersion} at ${installation.config.appUrl}`
+var observeEdgeCertificate = async (runtime, installation, host) => {
+  const listed = await runtime.run(
+    "docker",
+    serverComposeArgs(composeTarget(installation), [
+      "exec",
+      "-T",
+      "edge",
+      "sh",
+      "-c",
+      `ls /data/caddy/certificates/*/${host}/${host}.crt`
+    ]),
+    { timeoutMs: serverProcessDeadlines.ordinary }
   );
+  if (listed.error !== void 0) return { kind: "unavailable", reason: listed.error };
+  if (listed.status !== 0) {
+    return /No such file or directory/.test(listed.stderr) ? { kind: "none" } : {
+      kind: "unavailable",
+      reason: listed.stderr.trim() || `exit ${listed.status ?? "unknown"}`
+    };
+  }
+  const file = listed.stdout.trim().split("\n")[0];
+  return file === void 0 || file === "" ? { kind: "none" } : { kind: "observed", file };
+};
+var operatorReportLines = async (runtime, installation) => {
+  const login2 = runtime.readLogin?.(runtime.configDir) ?? null;
+  if (login2 === null) {
+    return [
+      `gate items \xB7 every item with its detail needs the operator's sign-in on this machine: mend login --url ${installation.config.appUrl}, then mend server status again, or mend operator gate and mend operator exposure`
+    ];
+  }
+  let loginOrigin;
+  try {
+    loginOrigin = new URL(login2.url).origin;
+  } catch {
+    return [`gate items \xB7 the saved sign-in's URL "${login2.url}" is not a URL \xB7 not read`];
+  }
+  if (loginOrigin !== installation.config.appUrl) {
+    return [
+      `gate items \xB7 this machine is signed in to ${loginOrigin}, not ${installation.config.appUrl} \xB7 not read`
+    ];
+  }
+  const headers = { Authorization: `Bearer ${login2.token}` };
+  const read = async (route) => {
+    const response = await runtime.fetchText(
+      `${healthOrigin(installation.config)}/api${route}`,
+      5e3,
+      headers
+    );
+    if (response.error !== void 0) return `${route} \xB7 not read: ${response.error}`;
+    if (response.status === 404)
+      return `${route} \xB7 404: the signed-in account does not hold the operator role`;
+    if (response.status < 200 || response.status >= 300)
+      return `${route} \xB7 not read: HTTP ${response.status}`;
+    try {
+      return JSON.parse(response.body);
+    } catch {
+      return `${route} \xB7 not read: the answer is not JSON`;
+    }
+  };
+  const lines = [];
+  const gate = await read("/operator/gate");
+  const gateItems = Array.isArray(gate) ? gate.flatMap(gateItemOf) : null;
+  if (typeof gate === "string") lines.push(`gate items \xB7 ${gate}`);
+  else if (gateItems === null || gateItems.length === 0)
+    lines.push("gate items \xB7 /operator/gate answered in a shape this CLI does not read");
+  else lines.push("multi mode gate, as the server reports each item:", ...renderGate(gateItems));
+  const exposure = await read("/operator/exposure");
+  const report = exposureReportOf(exposure);
+  if (typeof exposure === "string") lines.push(`gate items \xB7 ${exposure}`);
+  else if (report === null)
+    lines.push("gate items \xB7 /operator/exposure answered in a shape this CLI does not read");
+  else
+    lines.push("public exposure gate, as the server reports each item:", ...renderExposure(report));
+  return lines;
+};
+var gateItemOf = (value) => {
+  const fields = ownFields(value);
+  const id = fields?.get("id");
+  const ok = fields?.get("ok");
+  const detail = fields?.get("detail");
+  const fix = fields?.get("fix");
+  return typeof id === "string" && typeof ok === "boolean" && typeof detail === "string" && (fix === null || typeof fix === "string") ? [{ id, ok, detail, fix: fix ?? null }] : [];
+};
+var isEstablished = (value) => value === "observed" || value === "carried" || value === "declared" || value === "open";
+var exposureItemOf = (value) => {
+  const fields = ownFields(value);
+  const id = fields?.get("id");
+  const established = fields?.get("established");
+  const detail = fields?.get("detail");
+  const fix = fields?.get("fix");
+  const blocksStart = fields?.get("blocksStart");
+  return typeof id === "string" && isEstablished(established) && typeof detail === "string" && (fix === null || typeof fix === "string") && typeof blocksStart === "boolean" ? [{ id, established, detail, fix: fix ?? null, blocksStart }] : [];
+};
+var exposureReportOf = (value) => {
+  const fields = ownFields(value);
+  const declared = fields?.get("declared");
+  const items = fields?.get("items");
+  if (typeof declared !== "string" || !isExposure(declared) || !Array.isArray(items)) return null;
+  const parsed = items.flatMap(exposureItemOf);
+  return parsed.length === items.length && parsed.length > 0 ? { declared, items: parsed } : null;
+};
+var serverStatus = async (runtime, installation) => {
+  const { config } = installation;
+  runtime.writeLine(`Pinned Mend ${config.serverVersion} at ${config.appUrl}`);
   runtime.writeLine(`Active generation: ${installation.directory}`);
+  for (const line of declaredPostureLines(config)) runtime.writeLine(line);
   const state = await composeCommand(runtime, installation, ["ps", "--all"]);
   runtime.writeLine(state.stdout.trim() || "No Compose containers found. Run mend server start.");
   const running = await composeCommand(runtime, installation, [
@@ -6150,24 +7784,36 @@ var serverStatus = async (runtime, installation) => {
     "running",
     "--services"
   ]);
-  if (!running.stdout.trim().split(/\s+/).includes("mend")) {
+  const runningServices = running.stdout.trim().split(/\s+/);
+  if (config.edgeHost !== void 0) {
+    const edgeRunning = runningServices.includes("edge");
+    runtime.writeLine(
+      observedEdgeLine(config.edgeHost, {
+        running: edgeRunning,
+        certificate: edgeRunning ? await observeEdgeCertificate(runtime, installation, config.edgeHost) : { kind: "unavailable", reason: "the edge is not running, so its data was not read" }
+      })
+    );
+  }
+  if (!runningServices.includes("mend")) {
     runtime.writeLine("Mend is stopped. No health claim was made.");
     return;
   }
-  const response = await runtime.fetchText(`${installation.config.appUrl}/api/health`, 2e3);
+  const response = await runtime.fetchText(`${healthOrigin(config)}/api/health`, 2e3);
   let fields = null;
+  let body = null;
   try {
-    fields = ownFields(JSON.parse(response.body));
+    body = JSON.parse(response.body);
+    fields = ownFields(body);
   } catch {
   }
-  if (response.error !== void 0 || response.status < 200 || response.status >= 300 || fields?.get("status") !== "ok" || fields.get("version") !== installation.config.serverVersion) {
+  if (response.error !== void 0 || response.status < 200 || response.status >= 300 || fields?.get("status") !== "ok" || fields.get("version") !== config.serverVersion) {
     throw setupError(
-      `Mend is running but exact-version health for ${installation.config.serverVersion} was not observed. Check mend server logs --tail 100.`
+      `Mend is running but exact-version health for ${config.serverVersion} was not observed. Check mend server logs --tail 100.`
     );
   }
-  runtime.writeLine(
-    `Mend ${installation.config.serverVersion} is reachable at ${installation.config.appUrl}`
-  );
+  runtime.writeLine(reachableLine(config));
+  for (const line of observedPostureLines(config, healthPosture(body))) runtime.writeLine(line);
+  for (const line of await operatorReportLines(runtime, installation)) runtime.writeLine(line);
 };
 var manageServer = async (command, args, runtime, store) => {
   const installation = storeValue(readServerInstallation(store));
@@ -6212,12 +7858,18 @@ var manageServer = async (command, args, runtime, store) => {
   if (command === "stop") {
     interruptionNotice(runtime);
     await composeCommand(runtime, installation, ["stop", "--timeout", "30"]);
+    const stopped = [
+      "Mend",
+      "Postgres",
+      ...installation.config.bucket === "garage" ? ["Garage"] : [],
+      ...installation.config.edgeHost === void 0 ? [] : ["the edge"]
+    ];
     runtime.writeLine(
-      `Mend, Postgres${installation.config.bucket === "garage" ? " and Garage" : ""} stopped. Volumes, configuration and workspace containers are retained.`
+      `${stopped.slice(0, -1).join(", ")} and ${stopped.at(-1)} stopped. Volumes, configuration and workspace containers are retained.`
     );
     return;
   }
-  await checkLocalImages(runtime, installation.config);
+  await checkLocalImages(runtime, installation);
   if (command === "restart") {
     interruptionNotice(runtime);
     await composeCommand(runtime, installation, ["stop", "--timeout", "30", "mend"]);
@@ -6226,16 +7878,19 @@ var manageServer = async (command, args, runtime, store) => {
 };
 var nodeServerRuntime = () => {
   const environment = { ...process.env };
-  const home = os8.homedir();
-  const configHome = environment["XDG_CONFIG_HOME"] ?? path13.join(home, ".config");
+  const home = os10.homedir();
+  const configHome = environment["XDG_CONFIG_HOME"] ?? path16.join(home, ".config");
   return {
-    configDir: path13.join(configHome, "mend"),
+    configDir: path16.join(configHome, "mend"),
     platform: process.platform,
     cliVersion: cliVersion(),
     run: (command, args, options) => runServerProcess(command, args, environment, options),
-    fetchText: async (url, timeoutMs) => {
+    fetchText: async (url, timeoutMs, headers) => {
       try {
-        const response = await fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
+        const response = await fetch(url, {
+          signal: AbortSignal.timeout(timeoutMs),
+          ...headers === void 0 ? {} : { headers }
+        });
         return { status: response.status, body: await response.text() };
       } catch (cause) {
         return {
@@ -6246,12 +7901,26 @@ var nodeServerRuntime = () => {
       }
     },
     randomBytes,
-    sleep: (milliseconds) => new Promise((resolve7) => setTimeout(resolve7, milliseconds)),
+    sleep: (milliseconds) => new Promise((resolve8) => setTimeout(resolve8, milliseconds)),
     writeLine: (line) => process.stdout.write(`${line}
 `),
-    dockerDaemonFacts: hostDockerDaemonFacts
+    dockerDaemonFacts: hostDockerDaemonFacts,
+    readLogin: (configDir) => savedLogin(configDir, environment)
   };
 };
+var savedLogin = (configDir, environment) => {
+  let saved = null;
+  try {
+    saved = ownFields(JSON.parse(fs16.readFileSync(path16.join(configDir, "cli.json"), "utf8")));
+  } catch {
+    saved = null;
+  }
+  const savedUrl = saved?.get("url");
+  const savedToken = saved?.get("token");
+  const url = environment["MEND_URL"] ?? (typeof savedUrl === "string" ? savedUrl : null);
+  const token = environment["MEND_TOKEN"] ?? (typeof savedToken === "string" ? savedToken : null);
+  return url === null || token === null || token === "" ? null : { url, token };
+};
 var serverCommand = async (args, runtime = nodeServerRuntime()) => {
   const [command, ...rest] = args;
   if (command === void 0 || !["setup", "status", "start", "stop", "restart", "logs", "upgrade"].includes(command)) {
@@ -6456,7 +8125,7 @@ var renderMendToml = (proposals) => {
 };
 
 // src/service-tunnels.ts
-import * as net3 from "node:net";
+import * as net4 from "node:net";
 var attachTunnelTargets = (services, sessionId) => services.filter(
   (service) => service.sessionId === sessionId && service.protocol === "tcp" && service.browserScheme !== null
 );
@@ -6497,7 +8166,7 @@ var pumpConnection = (socket, url) => {
     () => socket.destroy()
   );
 };
-var listenLocal = (server, port, fallback) => new Promise((resolve7, reject) => {
+var listenLocal = (server, port, fallback) => new Promise((resolve8, reject) => {
   const attempt2 = (candidate, lastTry) => {
     const onError = (error) => {
       if (!lastTry) {
@@ -6510,7 +8179,7 @@ var listenLocal = (server, port, fallback) => new Promise((resolve7, reject) =>
     server.listen(candidate, "127.0.0.1", () => {
       server.removeListener("error", onError);
       const address = server.address();
-      resolve7(typeof address === "object" && address !== null ? address.port : candidate);
+      resolve8(typeof address === "object" && address !== null ? address.port : candidate);
     });
   };
   attempt2(port, !fallback || port === 0);
@@ -6539,7 +8208,7 @@ var serverEvents = (config) => async (handlers, signal) => {
       if (signal.aborted) return;
     }
     connected = true;
-    await new Promise((resolve7) => setTimeout(resolve7, 2e3));
+    await new Promise((resolve8) => setTimeout(resolve8, 2e3));
   }
 };
 var createServiceTunnels = (options) => {
@@ -6568,7 +8237,7 @@ var createServiceTunnels = (options) => {
   };
   const openFor = async (service) => {
     const sockets = /* @__PURE__ */ new Set();
-    const server = net3.createServer((socket) => {
+    const server = net4.createServer((socket) => {
       sockets.add(socket);
       socket.on("close", () => sockets.delete(socket));
       pumpConnection(socket, options.tunnelUrl(service.id));
@@ -6682,8 +8351,8 @@ var createServiceTunnels = (options) => {
 };
 
 // src/skills.ts
-import * as fs14 from "node:fs";
-import * as path14 from "node:path";
+import * as fs17 from "node:fs";
+import * as path17 from "node:path";
 var DEFAULT_SKILLS_DIR = ".agents/skills";
 var MAX_SKILL_FILES = 64;
 var MAX_SKILL_FILE_BYTES = 512 * 1024;
@@ -6706,12 +8375,12 @@ var readFrontmatterDescription = (contents) => {
 var walkFiles = (root) => {
   const found = [];
   const visit = (dir) => {
-    for (const entry of fs14.readdirSync(dir, { withFileTypes: true })) {
+    for (const entry of fs17.readdirSync(dir, { withFileTypes: true })) {
       if (IGNORED_DIRS.has(entry.name)) continue;
-      const absolute = path14.join(dir, entry.name);
+      const absolute = path17.join(dir, entry.name);
       let stat;
       try {
-        stat = fs14.statSync(absolute);
+        stat = fs17.statSync(absolute);
       } catch {
         continue;
       }
@@ -6725,7 +8394,7 @@ var walkFiles = (root) => {
 var scanSkillLibrary = (root) => {
   let entries;
   try {
-    entries = fs14.readdirSync(root, { withFileTypes: true });
+    entries = fs17.readdirSync(root, { withFileTypes: true });
   } catch {
     return { error: `${root} is not a readable directory` };
   }
@@ -6733,32 +8402,32 @@ var scanSkillLibrary = (root) => {
   const notes = [];
   for (const entry of entries.toSorted((a, b) => a.name.localeCompare(b.name))) {
     if (entry.name.startsWith(".")) continue;
-    const skillDir = path14.join(root, entry.name);
+    const skillDir = path17.join(root, entry.name);
     let stat;
     try {
-      stat = fs14.statSync(skillDir);
+      stat = fs17.statSync(skillDir);
     } catch {
       continue;
     }
     if (!stat.isDirectory()) continue;
-    if (!fs14.existsSync(path14.join(skillDir, "SKILL.md"))) {
+    if (!fs17.existsSync(path17.join(skillDir, "SKILL.md"))) {
       notes.push({ skill: entry.name, message: "no SKILL.md \u2014 skipped" });
       continue;
     }
     const files = [];
     let bytes = 0;
     for (const absolute of walkFiles(skillDir)) {
-      const relative4 = path14.relative(skillDir, absolute).split(path14.sep).join("/");
-      const buffer = fs14.readFileSync(absolute);
+      const relative5 = path17.relative(skillDir, absolute).split(path17.sep).join("/");
+      const buffer = fs17.readFileSync(absolute);
       if (buffer.byteLength > MAX_SKILL_FILE_BYTES) {
-        notes.push({ skill: entry.name, message: `${relative4} is over 512KB \u2014 skipped` });
+        notes.push({ skill: entry.name, message: `${relative5} is over 512KB \u2014 skipped` });
         continue;
       }
       if (!isTextBuffer(buffer)) {
-        notes.push({ skill: entry.name, message: `${relative4} is binary \u2014 skipped` });
+        notes.push({ skill: entry.name, message: `${relative5} is binary \u2014 skipped` });
         continue;
       }
-      files.push({ path: relative4, contents: buffer.toString("utf8") });
+      files.push({ path: relative5, contents: buffer.toString("utf8") });
       bytes += buffer.byteLength;
     }
     if (files.length > MAX_SKILL_FILES) {
@@ -6784,16 +8453,16 @@ var scanSkillLibrary = (root) => {
 };
 
 // src/ssh-setup.ts
-import * as os10 from "node:os";
-import * as path16 from "node:path";
+import * as os12 from "node:os";
+import * as path19 from "node:path";
 
 // ../../packages/workspace-ssh/src/index.ts
 import { spawnSync as spawnSync5 } from "node:child_process";
 import { createHash as createHash3 } from "node:crypto";
-import * as fs15 from "node:fs";
-import { isIP as isIP2 } from "node:net";
-import * as os9 from "node:os";
-import * as path15 from "node:path";
+import * as fs18 from "node:fs";
+import { isIP as isIP3 } from "node:net";
+import * as os11 from "node:os";
+import * as path18 from "node:path";
 var LEGACY_BLOCK_BEGIN = "# >>> mend workspace ssh (managed by `mend ssh setup`) >>>";
 var LEGACY_BLOCK_END = "# <<< mend workspace ssh <<<";
 var WorkspaceSshError = class extends Error {
@@ -6810,16 +8479,16 @@ var WorkspaceSshError = class extends Error {
 };
 var success = (value) => ({ ok: true, value });
 var failure = (error) => ({ ok: false, error });
-var stripIpv6Brackets = (hostname7) => hostname7.startsWith("[") && hostname7.endsWith("]") ? hostname7.slice(1, -1) : hostname7;
+var stripIpv6Brackets = (hostname8) => hostname8.startsWith("[") && hostname8.endsWith("]") ? hostname8.slice(1, -1) : hostname8;
 var hashIdentity = (identity) => createHash3("sha256").update(identity).digest("hex").slice(0, 24);
-var aliasLabel = (hostname7) => {
-  const label = hostname7.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 24);
+var aliasLabel = (hostname8) => {
+  const label = hostname8.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 24);
   return label === "" ? "server" : label;
 };
 var parseHostOverride = (raw) => {
-  const hostname7 = raw.trim();
-  if (hostname7 === "") return failure(new WorkspaceSshError("target", "SSH hostname is empty."));
-  if (hostname7.includes("://") || /[\s/@]/.test(hostname7)) {
+  const hostname8 = raw.trim();
+  if (hostname8 === "") return failure(new WorkspaceSshError("target", "SSH hostname is empty."));
+  if (hostname8.includes("://") || /[\s/@]/.test(hostname8)) {
     return failure(
       new WorkspaceSshError(
         "target",
@@ -6827,7 +8496,7 @@ var parseHostOverride = (raw) => {
       )
     );
   }
-  if (/^[^:]+:\d+$/.test(hostname7)) {
+  if (/^[^:]+:\d+$/.test(hostname8)) {
     return failure(
       new WorkspaceSshError(
         "target",
@@ -6835,11 +8504,11 @@ var parseHostOverride = (raw) => {
       )
     );
   }
-  if ((hostname7.startsWith("[") || hostname7.endsWith("]")) && !/^\[[^\]]+\]$/.test(hostname7)) {
+  if ((hostname8.startsWith("[") || hostname8.endsWith("]")) && !/^\[[^\]]+\]$/.test(hostname8)) {
     return failure(new WorkspaceSshError("target", "SSH hostname contains invalid IPv6 brackets."));
   }
-  const unbracketed = stripIpv6Brackets(hostname7);
-  if ((hostname7.startsWith("[") || unbracketed.includes(":")) && isIP2(unbracketed) !== 6) {
+  const unbracketed = stripIpv6Brackets(hostname8);
+  if ((hostname8.startsWith("[") || unbracketed.includes(":")) && isIP3(unbracketed) !== 6) {
     return failure(
       new WorkspaceSshError("target", "SSH hostname contains an invalid IPv6 address.")
     );
@@ -6880,8 +8549,8 @@ var blockBegin = (alias) => `# >>> mend workspace ssh ${alias} (managed) >>>`;
 var blockEnd = (alias) => `# <<< mend workspace ssh ${alias} <<<`;
 var hasControls = (value) => /[\p{Cc}\p{Zl}\p{Zp}]/u.test(value);
 var parseIdentityPath = (value) => {
-  const resolved = path15.resolve(
-    value.startsWith("~/") ? path15.join(os9.homedir(), value.slice(2)) : value
+  const resolved = path18.resolve(
+    value.startsWith("~/") ? path18.join(os11.homedir(), value.slice(2)) : value
   );
   if (value === "" || hasControls(value) || hasControls(resolved) || value.includes("${") || resolved.includes("${")) {
     return failure(
@@ -7037,7 +8706,7 @@ var agentKeys = () => {
 };
 var readText = (file) => {
   try {
-    return success(fs15.readFileSync(file, "utf8"));
+    return success(fs18.readFileSync(file, "utf8"));
   } catch (cause) {
     const error = cause instanceof Error && "code" in cause ? cause.code : void 0;
     return error === "ENOENT" ? success("") : failure(new WorkspaceSshError("key", `Could not read ${file}.`, cause));
@@ -7095,19 +8764,19 @@ var readRequiredKey = (keyPath, source) => {
 var readOptionalKey = (keyPath) => {
   const parsed = parseIdentityPath(keyPath);
   if (!parsed.ok) return parsed;
-  if (!fs15.existsSync(parsed.value) && !fs15.existsSync(publicKeyPath(parsed.value)))
+  if (!fs18.existsSync(parsed.value) && !fs18.existsSync(publicKeyPath(parsed.value)))
     return success(null);
   return readRequiredKey(parsed.value, "existing");
 };
 var pinAgentKey = (configHome, publicKey) => {
-  const identityFile = path15.resolve(
+  const identityFile = path18.resolve(
     configHome,
     "ssh",
     `agent-${hashIdentity(publicKeyIdentity(publicKey))}.pub`
   );
   try {
-    fs15.mkdirSync(path15.dirname(identityFile), { recursive: true, mode: 448 });
-    fs15.writeFileSync(identityFile, `${publicKey}
+    fs18.mkdirSync(path18.dirname(identityFile), { recursive: true, mode: 448 });
+    fs18.writeFileSync(identityFile, `${publicKey}
 `, { mode: 384 });
     return success({ publicKey, identityFile, source: "agent" });
   } catch (cause) {
@@ -7118,15 +8787,15 @@ var pinAgentKey = (configHome, publicKey) => {
 };
 var generateDedicatedKey = (privatePath) => {
   try {
-    fs15.mkdirSync(path15.dirname(privatePath), { recursive: true, mode: 448 });
+    fs18.mkdirSync(path18.dirname(privatePath), { recursive: true, mode: 448 });
   } catch (cause) {
     return failure(
-      new WorkspaceSshError("key", `Could not create ${path15.dirname(privatePath)}.`, cause)
+      new WorkspaceSshError("key", `Could not create ${path18.dirname(privatePath)}.`, cause)
     );
   }
   const generated = spawnSync5(
     "ssh-keygen",
-    ["-t", "ed25519", "-f", privatePath, "-N", "", "-C", `mend-${os9.hostname()}`],
+    ["-t", "ed25519", "-f", privatePath, "-N", "", "-C", `mend-${os11.hostname()}`],
     { encoding: "utf8", timeout: 3e3, stdio: ["ignore", "pipe", "pipe"] }
   );
   if (generated.status !== 0) {
@@ -7150,7 +8819,7 @@ var generateDedicatedKey = (privatePath) => {
   return fresh;
 };
 var dedicatedKey = (configHome, create) => {
-  const privatePath = path15.join(configHome, "ssh", "id_ed25519");
+  const privatePath = path18.join(configHome, "ssh", "id_ed25519");
   const existing = readOptionalKey(privatePath);
   if (existing.ok === false) return failure(existing.error);
   if (existing.value !== null || !create) return existing;
@@ -7198,10 +8867,10 @@ var writeWorkspaceSshConfig = (configFile, target, identityFile) => {
   const reconciled = reconcileWorkspaceSshConfig(before.value, target, identityFile);
   if (reconciled.ok === false) return failure(reconciled.error);
   try {
-    fs15.mkdirSync(path15.dirname(configFile), { recursive: true, mode: 448 });
-    fs15.chmodSync(path15.dirname(configFile), 448);
-    fs15.writeFileSync(configFile, reconciled.value, { mode: 384 });
-    fs15.chmodSync(configFile, 384);
+    fs18.mkdirSync(path18.dirname(configFile), { recursive: true, mode: 448 });
+    fs18.chmodSync(path18.dirname(configFile), 448);
+    fs18.writeFileSync(configFile, reconciled.value, { mode: 384 });
+    fs18.chmodSync(configFile, 384);
     return success(void 0);
   } catch (cause) {
     return failure(new WorkspaceSshError("config", `Could not write ${configFile}.`, cause));
@@ -7214,7 +8883,7 @@ var dim5 = ansi("2");
 var green5 = ansi("32");
 var warn = ansi("33");
 var say5 = (line) => console.log(line);
-var sshConfigPath = () => path16.join(os10.homedir(), ".ssh", "config");
+var sshConfigPath = () => path19.join(os12.homedir(), ".ssh", "config");
 var flagValue2 = (args, flag) => {
   const index = args.indexOf(flag);
   return index === -1 || args[index + 1] === void 0 ? null : String(args[index + 1]);
@@ -7284,7 +8953,7 @@ var setup = async (api2, cliHome, serverUrl, args) => {
   if (picked.value === null) return showFailure("No workspace SSH key is available.");
   const registered = await api2("POST", "/workspace-ssh/keys", {
     publicKey: picked.value.publicKey,
-    name: os10.hostname()
+    name: os12.hostname()
   });
   const sourceLabel = {
     explicit: "from --key",
@@ -7326,8 +8995,8 @@ var sshCommand = async (args, api2, cliHome, serverUrl) => {
 };
 
 // src/uninstall.ts
-import * as fs16 from "node:fs";
-import * as path17 from "node:path";
+import * as fs19 from "node:fs";
+import * as path20 from "node:path";
 var UNINSTALL_USAGE = "usage: mend uninstall [--all | --server | --home] [--yes]";
 var parseUninstallArgs = (args) => {
   let scope = null;
@@ -7349,14 +9018,14 @@ var parseUninstallArgs = (args) => {
 var SERVER_FILES = ["identity.env", "active", "generations", "backups"];
 var countEntries = (directory) => {
   try {
-    return fs16.readdirSync(directory).length;
+    return fs19.readdirSync(directory).length;
   } catch {
     return 0;
   }
 };
 var exists = (file) => {
   try {
-    fs16.lstatSync(file);
+    fs19.lstatSync(file);
     return true;
   } catch {
     return false;
@@ -7365,7 +9034,7 @@ var exists = (file) => {
 var managedBlockCount = (sshConfigFile) => {
   let config;
   try {
-    config = fs16.readFileSync(sshConfigFile, "utf8");
+    config = fs19.readFileSync(sshConfigFile, "utf8");
   } catch {
     return 0;
   }
@@ -7389,27 +9058,29 @@ var describeUninstall = async (runtime, scope) => {
       if (!read.error.message.startsWith("No Mend server is configured")) throw read.error;
       server = "none";
     } else if (read.value === null) {
-      server = exists(path17.join(configDir, "identity.env")) ? {
+      server = exists(path20.join(configDir, "identity.env")) ? {
         version: "(no active generation)",
         appUrl: "",
         dockerContext: "",
-        generations: countEntries(path17.join(configDir, "generations")),
-        backups: countEntries(path17.join(configDir, "backups"))
+        edgeHost: null,
+        generations: countEntries(path20.join(configDir, "generations")),
+        backups: countEntries(path20.join(configDir, "backups"))
       } : "none";
     } else {
       server = {
         version: read.value.config.serverVersion,
         appUrl: read.value.config.appUrl,
         dockerContext: read.value.config.dockerContext,
-        generations: countEntries(path17.join(configDir, "generations")),
-        backups: countEntries(path17.join(configDir, "backups"))
+        edgeHost: read.value.config.edgeHost ?? null,
+        generations: countEntries(path20.join(configDir, "generations")),
+        backups: countEntries(path20.join(configDir, "backups"))
       };
     }
   }
   let home = null;
   if (scope !== "server") {
-    const cliConfig = path17.join(runtime.cliHome, "cli.json");
-    const sshDirectory = path17.join(runtime.cliHome, "ssh");
+    const cliConfig = path20.join(runtime.cliHome, "cli.json");
+    const sshDirectory = path20.join(runtime.cliHome, "ssh");
     home = {
       cliConfig: exists(cliConfig) ? cliConfig : null,
       sshDirectory: exists(sshDirectory) ? sshDirectory : null,
@@ -7425,13 +9096,15 @@ var planLines = (plan, configDir) => {
   if (plan.server === "none") {
     lines.push(`server   none installed under ${configDir}`);
   } else if (plan.server !== null) {
-    const { version, appUrl, dockerContext, generations, backups } = plan.server;
+    const { version, appUrl, dockerContext, edgeHost, generations, backups } = plan.server;
     lines.push(
       `server   Mend ${version}${appUrl === "" ? "" : ` at ${appUrl}`}${dockerContext === "" ? "" : ` \xB7 docker context ${dockerContext}`}`
     );
     if (dockerContext !== "") {
+      const edge = edgeHost === null ? [] : ["edge"];
+      const edgeVolumes = edgeHost === null ? [] : ["mend-edge-data", "mend-edge-config"];
       lines.push(
-        `         containers mend, postgres, garage \xB7 volumes ${[MEND_DOCKER_NAMESPACE_WITH_GARAGE.store, ...secondaryVolumesOf(MEND_DOCKER_NAMESPACE_WITH_GARAGE), "mend-config", "mend-ssh", "mend-postgres"].join(", ")} \xB7 image ghcr.io/sealant-sh/mend:${version}`
+        `         containers ${["mend", "postgres", "garage", ...edge].join(", ")} \xB7 volumes ${[MEND_DOCKER_NAMESPACE_WITH_GARAGE.store, ...secondaryVolumesOf(MEND_DOCKER_NAMESPACE_WITH_GARAGE), "mend-config", "mend-ssh", "mend-postgres", ...edgeVolumes].join(", ")} \xB7 image ghcr.io/sealant-sh/mend:${version}${edgeHost === null ? "" : ` \xB7 the edge for ${edgeHost}`}`
       );
     }
     lines.push(
@@ -7473,13 +9146,14 @@ var removeServer = async (runtime, failures, leftovers) => {
         const context = installation.config.dockerContext;
         const down = await server.run(
           "docker",
-          serverComposeArgs({ directory: installation.directory, dockerContext: context }, [
-            "down",
-            "--volumes",
-            "--remove-orphans",
-            "--timeout",
-            "30"
-          ]),
+          serverComposeArgs(
+            {
+              directory: installation.directory,
+              dockerContext: context,
+              overlays: composeOverlays(installation.config)
+            },
+            ["down", "--volumes", "--remove-orphans", "--timeout", "30"]
+          ),
           { timeoutMs: serverProcessDeadlines.stop }
         );
         if (down.status !== 0) {
@@ -7541,7 +9215,7 @@ var removeServer = async (runtime, failures, leftovers) => {
         }
       }
       for (const name of SERVER_FILES) {
-        fs16.rmSync(path17.join(configDir, name), { recursive: true, force: true });
+        fs19.rmSync(path20.join(configDir, name), { recursive: true, force: true });
       }
       server.writeLine(`removed ${configDir}/{identity.env, active, generations, backups}`);
     },
@@ -7552,20 +9226,20 @@ var removeServer = async (runtime, failures, leftovers) => {
 var removeHome = async (runtime, plan, failures, leftovers) => {
   const { server } = runtime;
   if (plan.cliConfig !== null) {
-    fs16.rmSync(plan.cliConfig, { force: true });
+    fs19.rmSync(plan.cliConfig, { force: true });
     server.writeLine(`removed ${plan.cliConfig}`);
   }
   if (plan.sshDirectory !== null) {
-    fs16.rmSync(plan.sshDirectory, { recursive: true, force: true });
+    fs19.rmSync(plan.sshDirectory, { recursive: true, force: true });
     server.writeLine(`removed ${plan.sshDirectory}`);
   }
   if (plan.managedSshBlocks > 0) {
     try {
-      const before = fs16.readFileSync(runtime.sshConfigFile, "utf8");
+      const before = fs19.readFileSync(runtime.sshConfigFile, "utf8");
       const stripped = stripManagedWorkspaceSshBlocks(before);
       if (!stripped.ok) throw stripped.error;
       if (stripped.value.removed > 0) {
-        fs16.writeFileSync(runtime.sshConfigFile, stripped.value.config, { mode: 384 });
+        fs19.writeFileSync(runtime.sshConfigFile, stripped.value.config, { mode: 384 });
         server.writeLine(
           `removed ${plural(stripped.value.removed, "managed block")} from ${runtime.sshConfigFile}`
         );
@@ -7578,12 +9252,12 @@ var removeHome = async (runtime, plan, failures, leftovers) => {
   }
   let remaining = [];
   try {
-    remaining = fs16.readdirSync(runtime.cliHome);
+    remaining = fs19.readdirSync(runtime.cliHome);
   } catch {
     return;
   }
   if (remaining.length === 0) {
-    fs16.rmdirSync(runtime.cliHome);
+    fs19.rmdirSync(runtime.cliHome);
     server.writeLine(`removed ${runtime.cliHome}`);
   } else {
     leftovers.push(
@@ -7644,22 +9318,103 @@ var upgradeUrl = async (input) => {
   return url;
 };
 
+// src/worktree-remove.ts
+var parseWorktreesRmArgs = (args) => {
+  let name = null;
+  let force = false;
+  let project2 = null;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === void 0) continue;
+    if (arg === "--force") {
+      force = true;
+      continue;
+    }
+    if (arg === "--project") {
+      const value = args[index + 1];
+      if (value === void 0 || value.startsWith("--")) return { error: "--project needs a name" };
+      project2 = value;
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--"))
+      return { error: `unknown option ${arg} \xB7 ${usageOf("worktrees rm")}` };
+    if (name !== null) return { error: `one worktree at a time \xB7 ${usageOf("worktrees rm")}` };
+    name = arg;
+  }
+  if (name === null) return { error: usageOf("worktrees rm") };
+  return { args: { name, force, project: project2 } };
+};
+var plural2 = (count, one, many) => `${count} ${count === 1 ? one : many}`;
+var pickWorktree = (worktrees, name, liveStatuses) => {
+  const matches = worktrees.filter((worktree2) => worktree2.name === name);
+  const [worktree] = matches;
+  if (worktree === void 0)
+    return { error: `no worktree named ${name} \xB7 mend worktrees lists them` };
+  if (matches.length > 1) {
+    return {
+      error: `${name} names a worktree in ${matches.length} projects: ${matches.map((match) => match.projectName).join(", ")} \xB7 say which with --project`
+    };
+  }
+  const id = worktree.id;
+  if (id === null) {
+    return { error: `this server predates worktrees \xB7 mend sessions lists what it holds` };
+  }
+  const live = worktree.sessions.filter((session) => liveStatuses.has(session.status));
+  if (live.length > 0) {
+    return {
+      error: `${plural2(live.length, "session", "sessions")} live in ${name} \xB7 stop ${live.length === 1 ? "it" : "them"} first: ${live.map((session) => `mend stop ${session.id.slice(0, 8)}`).join(" \xB7 ")}`
+    };
+  }
+  return { worktree: { ...worktree, id } };
+};
+var removalRoute = (id, force) => `/worktrees/${encodeURIComponent(id)}${force ? "?force=true" : ""}`;
+var refusalLines = (words, args) => words.includes(WORKTREE_REMOVAL_FORCE_HINT) ? [
+  words,
+  `  mend worktrees rm ${args.name}${args.project === null ? "" : ` --project ${args.project}`} --force removes it anyway`
+] : [words];
+var removedLine = (name) => `removed \xB7 ${name} \xB7 its sessions, change, checkpoints and review went with it`;
+var worktreesRmCommand = async (deps, argv) => {
+  const parsed = parseWorktreesRmArgs(argv);
+  if ("error" in parsed) return deps.fail(parsed.error);
+  const { args } = parsed;
+  const picked = pickWorktree(await deps.listWorktrees(args.project), args.name, deps.liveStatuses);
+  if ("error" in picked) return deps.fail(picked.error);
+  const { worktree } = picked;
+  let report;
+  try {
+    report = await deps.request("DELETE", removalRoute(worktree.id, args.force));
+  } catch (error) {
+    if (error instanceof MendRequestError && error.status === 422) {
+      return deps.fail(refusalLines(error.message, args).join("\n"));
+    }
+    return deps.fail(error instanceof Error ? error.message : String(error));
+  }
+  if (!report.removed) {
+    return deps.fail(
+      `not removed \xB7 ${args.name}${report.leftover === null ? "" : ` \xB7 ${report.leftover}`}`
+    );
+  }
+  deps.say(removedLine(args.name));
+  if (report.leftover !== null) deps.say(`left behind \xB7 ${report.leftover}`);
+};
+
 // src/main.ts
 var mendCliHome = () => {
   const xdg = process.env["XDG_CONFIG_HOME"];
-  const preferred = path18.join(
-    xdg === void 0 || xdg === "" ? path18.join(os11.homedir(), ".config") : xdg,
+  const preferred = path21.join(
+    xdg === void 0 || xdg === "" ? path21.join(os13.homedir(), ".config") : xdg,
     "mend"
   );
-  const legacy = path18.join(os11.homedir(), ".mend");
-  return !fs17.existsSync(preferred) && fs17.existsSync(legacy) ? legacy : preferred;
+  const legacy = path21.join(os13.homedir(), ".mend");
+  return !fs20.existsSync(preferred) && fs20.existsSync(legacy) ? legacy : preferred;
 };
-var CONFIG_PATH = path18.join(mendCliHome(), "cli.json");
+var CONFIG_PATH = path21.join(mendCliHome(), "cli.json");
 var loadConfig = () => {
   let fileConfig = {};
-  if (fs17.existsSync(CONFIG_PATH)) {
+  if (fs20.existsSync(CONFIG_PATH)) {
     try {
-      fileConfig = JSON.parse(fs17.readFileSync(CONFIG_PATH, "utf8"));
+      fileConfig = JSON.parse(fs20.readFileSync(CONFIG_PATH, "utf8"));
     } catch {
       fail6(`could not parse ${CONFIG_PATH}`);
     }
@@ -7849,10 +9604,10 @@ var withSpinner = async (label, work) => {
 var followStarting = async (config, sessionId, label, start) => {
   let line = label;
   const timers = /* @__PURE__ */ new Set();
-  const sleep3 = (ms) => new Promise((resolve7) => {
+  const sleep3 = (ms) => new Promise((resolve8) => {
     const timer = setTimeout(() => {
       timers.delete(timer);
-      resolve7();
+      resolve8();
     }, ms);
     timers.add(timer);
   });
@@ -7911,7 +9666,7 @@ var adopt = async (config, args) => {
   }
   const sourceIssue = repositoryCloneUrlIssue(source);
   if (sourceIssue !== null) return fail6(sourceIssue);
-  const projectName = name ?? normalizeProjectName(path18.basename(source, ".git"));
+  const projectName = name ?? normalizeProjectName(path21.basename(source, ".git"));
   const auth = authFlagIndex !== -1 && args[authFlagIndex + 1] !== void 0 ? String(args[authFlagIndex + 1]) : null;
   if (auth !== null && auth !== "ambient" && auth !== "mend-key" && auth !== "bridge") {
     return fail6(`--auth takes "ambient", "mend-key", or "bridge", not "${auth}"`);
@@ -7935,6 +9690,14 @@ var adopt = async (config, args) => {
   say6(
     `${dim6("  sessions start with:")} mend codex ${dim6("(from anywhere \u2014")} --project ${project2.name}${dim6(")")}`
   );
+  const repoRoot = positional[0] === void 0 ? cwdFacts(process.cwd()).repoRoot : null;
+  const memory = repoRoot === null ? null : claudeMemoryDirFor(repoRoot);
+  if (memory !== null) {
+    const count = scanClaudeMemory(memory).files.length;
+    say6(
+      `${dim6("  claude memory")} ${count} file${count === 1 ? "" : "s"} on this machine ${dim6("\u2192 mend memory import")}`
+    );
+  }
 };
 var findProject = async (config, explicit, adoptCwd = false) => {
   const projects = await api(config, "GET", "/projects");
@@ -7960,7 +9723,7 @@ var findProject = async (config, explicit, adoptCwd = false) => {
   const sourceIssue = repositoryCloneUrlIssue(facts.originUrl);
   if (sourceIssue !== null) return fail6(sourceIssue);
   const adopted = await api(config, "POST", "/projects", {
-    name: normalizeProjectName(path18.basename(facts.repoRoot)),
+    name: normalizeProjectName(path21.basename(facts.repoRoot)),
     source: facts.originUrl
   });
   say6(`${green6("\u2713")} adopted \xB7 ${adopted.name} \xB7 ${dim6(adopted.storePath)}`);
@@ -8086,13 +9849,13 @@ var launch = async (config, harness, args) => {
   if (harness === "run") {
     return supervisedRun(config, session, argv);
   }
-  const launchBody = structured ? {
+  const launchBody = {
     ...parsed.prompt === null ? {} : { prompt: parsed.prompt },
     ...parsed.model === null ? {} : { model: parsed.model },
     ...parsed.effort === null ? {} : { effort: parsed.effort },
     ...parsed.ask ? { permissionMode: "ask" } : {},
     ...parsed.fast ? { speed: "fast" } : {}
-  } : { argv };
+  };
   await startAndFollow(
     config,
     session.id,
@@ -8147,6 +9910,7 @@ var takeTerminal = () => {
   }
   return { raw: true };
 };
+var WATCH_READ_GRACE_MS = 3e3;
 var terminalSize = () => ({
   cols: process.stdout.columns || 80,
   rows: process.stdout.rows || 24
@@ -8161,12 +9925,13 @@ var attachTty = async (config, sessionId, harness, from, processId, options) =>
     connecting.abort();
   };
   let ws = null;
+  let watching = false;
   let detached = false;
   let sawEnd = false;
   let interrupted = false;
   let finishAttachment;
-  const finished = new Promise((resolve7) => {
-    finishAttachment = resolve7;
+  const finished = new Promise((resolve8) => {
+    finishAttachment = resolve8;
   });
   const onSignal = () => {
     interrupted = true;
@@ -8176,7 +9941,7 @@ var attachTty = async (config, sessionId, harness, from, processId, options) =>
   };
   const signals = ["SIGHUP", "SIGINT", "SIGTERM"];
   const sendResize = (size = terminalSize()) => {
-    if (ws === null || ws.readyState !== WebSocket.OPEN) return;
+    if (watching || ws === null || ws.readyState !== WebSocket.OPEN) return;
     ws.send(JSON.stringify({ t: "resize", cols: size.cols, rows: size.rows }));
   };
   const onWinch = () => sendResize();
@@ -8211,6 +9976,13 @@ var attachTty = async (config, sessionId, harness, from, processId, options) =>
       else if (data.includes(3)) abort("interrupted");
       return;
     }
+    if (watching) {
+      if (watchKey(data, detachKeyEnabled) === null) return;
+      detached = true;
+      ws.close();
+      finishAttachment?.();
+      return;
+    }
     if (detachKeyEnabled && isDetachChunk(data)) {
       detached = true;
       ws.close();
@@ -8258,12 +10030,12 @@ var attachTty = async (config, sessionId, harness, from, processId, options) =>
     if (connecting.signal.aborted) return "aborted";
     const socket = new WebSocket(url);
     socket.binaryType = "arraybuffer";
-    const opened = await new Promise((resolve7) => {
-      const onAbort = () => resolve7(false);
+    const opened = await new Promise((resolve8) => {
+      const onAbort = () => resolve8(false);
       connecting.signal.addEventListener("abort", onAbort, { once: true });
       const settle = (value) => {
         connecting.signal.removeEventListener("abort", onAbort);
-        resolve7(value);
+        resolve8(value);
       };
       socket.addEventListener("open", () => settle(true), { once: true });
       socket.addEventListener("error", () => settle(false), { once: true });
@@ -8272,6 +10044,7 @@ var attachTty = async (config, sessionId, harness, from, processId, options) =>
     socket.close();
     return connecting.signal.aborted ? "aborted" : "unavailable";
   };
+  const detailRead = interactive ? request(config, "GET", `/sessions/${sessionId}`).catch(() => null) : Promise.resolve(null);
   const started = Date.now();
   let connectingShown = false;
   const connectingTimer = setInterval(() => {
@@ -8292,6 +10065,24 @@ var attachTty = async (config, sessionId, harness, from, processId, options) =>
       process.stdin.on("data", onKeys);
       process.stdin.resume();
     }
+    let graceTimer;
+    const detail = await Promise.race([
+      detailRead,
+      new Promise((resolve8) => {
+        graceTimer = setTimeout(() => resolve8(null), WATCH_READ_GRACE_MS);
+      })
+    ]);
+    clearTimeout(graceTimer);
+    if (watchesTerminal(detail)) {
+      watching = true;
+      const members = await request(config, "GET", "/organization/members").catch(() => []);
+      process.stdout.write(
+        `\r\x1B[2K${dim6(watchNotice(ownerNameOf(detail?.session.ownerUserId, members)))}\r
+${dim6(`read-only \xB7 ${detachKeyEnabled ? "Ctrl+] or " : ""}Ctrl+C detaches`)}\r
+\r
+`
+      );
+    }
     const connected = await connect2();
     stopConnecting();
     if (connected === "unavailable") return "unavailable";
@@ -8305,10 +10096,12 @@ var attachTty = async (config, sessionId, harness, from, processId, options) =>
         cancelHint: detachKeyEnabled ? "Ctrl+] detaches" : ""
       });
       starting = gate;
-      void request(config, "GET", `/sessions/${sessionId}`).then(
-        (detail) => gate.update(agentStartingFacts(detail.currentAgent, detail.processes, Date.now())),
-        () => void 0
-      );
+      void detailRead.then((read) => {
+        if (read !== null) {
+          gate.update(agentStartingFacts(read.currentAgent, read.processes, Date.now()));
+        }
+        return null;
+      });
     }
     stopHerdrHint = hintHerdrAttachment(harness);
     const onClose = () => finishAttachment?.();
@@ -8477,7 +10270,7 @@ var stopCommand = async (config, args) => {
   const all = args.includes("--all");
   const projectFlag = args.indexOf("--project");
   const projectName = projectFlag !== -1 && args[projectFlag + 1] !== void 0 ? String(args[projectFlag + 1]) : null;
-  const prefix = args.find((arg, index) => !arg.startsWith("--") && index !== projectFlag + 1);
+  const prefix = firstPositional(args, ["--project"]);
   if (!all && prefix === void 0 && projectName === null) {
     const picked = await resolveLiveSession(config, void 0, "stop");
     await stopSessions(config, [picked], false);
@@ -8581,7 +10374,7 @@ var resolveLiveSession = async (config, prefix, command) => {
   const candidates = project2 === void 0 ? sessions : sessions.filter((s) => s.projectId === project2.id);
   const only = candidates[0];
   if (only === void 0) {
-    return fail6("no live or retained session \u2014 start one with mend codex|claude|opencode");
+    return fail6("no live or retained session \u2014 start one with mend codex|claude|opencode|pi");
   }
   if (candidates.length === 1) return only;
   if (process.stdin.isTTY !== true) {
@@ -8854,9 +10647,7 @@ var serviceRun = async (config, args) => {
 var serviceLogs = async (config, args) => {
   const fromFlag = args.indexOf("--from");
   const from = fromFlag === -1 ? "0" : args[fromFlag + 1];
-  const needle = args.find(
-    (argument, index) => !argument.startsWith("--") && index !== fromFlag + 1
-  );
+  const needle = firstPositional(args, ["--from"]);
   if (needle === void 0 || from === void 0 || !/^(0|[1-9]\d*)$/.test(from)) {
     return fail6(usageOf("service logs"));
   }
@@ -8903,7 +10694,7 @@ var serviceLogs = async (config, args) => {
     cursor = page.nextFrom;
     const ended = page.status === "exited" || page.status === "failed";
     if (ended && !advanced) break;
-    if (!advanced) await new Promise((resolve7) => setTimeout(resolve7, 250));
+    if (!advanced) await new Promise((resolve8) => setTimeout(resolve8, 250));
   }
   say6("");
   say6(dim6(`stream ended \xB7 next sequence ${cursor}`));
@@ -8921,13 +10712,13 @@ var serviceRestart = async (config, args) => {
 };
 var serviceInit = async (args) => {
   const root = gitTopLevel(process.cwd()) ?? process.cwd();
-  const target = path18.join(root, "mend.toml");
-  if (fs17.existsSync(target)) {
+  const target = path21.join(root, "mend.toml");
+  if (fs20.existsSync(target)) {
     return fail6(`${target} already exists \u2014 edit it directly (init never merges)`);
   }
-  const rootFiles = fs17.readdirSync(root);
+  const rootFiles = fs20.readdirSync(root);
   const proposals = [];
-  const readRoot = (name) => fs17.readFileSync(path18.join(root, name), "utf8");
+  const readRoot = (name) => fs20.readFileSync(path21.join(root, name), "utf8");
   if (rootFiles.includes("package.json")) {
     proposals.push(...proposeFromPackageJson(readRoot("package.json"), rootFiles));
   }
@@ -8937,13 +10728,13 @@ var serviceInit = async (args) => {
   );
   for (const glob of globs) {
     const parent = glob.replace(/\/?\*+$/, "");
-    const dirs = glob.endsWith("*") ? fs17.existsSync(path18.join(root, parent)) ? fs17.readdirSync(path18.join(root, parent)).map((dir) => path18.join(parent, dir)) : [] : [glob];
+    const dirs = glob.endsWith("*") ? fs20.existsSync(path21.join(root, parent)) ? fs20.readdirSync(path21.join(root, parent)).map((dir) => path21.join(parent, dir)) : [] : [glob];
     for (const dir of dirs) {
-      const manifest = path18.join(root, dir, "package.json");
-      if (!fs17.existsSync(manifest)) continue;
+      const manifest = path21.join(root, dir, "package.json");
+      if (!fs20.existsSync(manifest)) continue;
       for (const proposal of proposeFromWorkspacePackage(
-        path18.basename(dir),
-        fs17.readFileSync(manifest, "utf8"),
+        path21.basename(dir),
+        fs20.readFileSync(manifest, "utf8"),
         rootFiles
       )) {
         if (!proposals.some((existing) => existing.name === proposal.name)) {
@@ -8987,13 +10778,13 @@ var serviceInit = async (args) => {
       return;
     }
   }
-  fs17.writeFileSync(target, toml);
+  fs20.writeFileSync(target, toml);
   say6(`${green6("\u2713")} wrote ${target} \u2014 commit it, then: mend service run ${proposals[0]?.name}`);
 };
 var tunnelServices = async (config, services, portOverride) => {
   for (const service of services) {
     const port = portOverride ?? service.hostPort ?? service.workspacePort;
-    const server = net4.createServer(
+    const server = net5.createServer(
       (socket) => pumpConnection(socket, tunnelUrlFor(config, service.id))
     );
     await listenLocal(server, port, false).catch(
@@ -9035,7 +10826,7 @@ var attachTunnels = (config, optOut) => {
     start: async (sessionId) => {
       await Promise.race([
         tunnels.focus(sessionId),
-        new Promise((resolve7) => setTimeout(resolve7, 3e3))
+        new Promise((resolve8) => setTimeout(resolve8, 3e3))
       ]);
     },
     attached: (work) => {
@@ -9090,19 +10881,173 @@ var serviceCommand = async (config, args) => {
       return serviceRun(config, [verb, ...rest]);
   }
 };
+var kilobytes = (bytes) => bytes < 1024 ? `${bytes} B` : `${(bytes / 1024).toFixed(1)} KB`;
+var memoryPathOf = (name) => {
+  if (name.startsWith(".")) return name;
+  const single = AGENT_MEMORY_FILES.find((file) => file.path.endsWith(`/${name}`));
+  if (single !== void 0) return single.path;
+  const qualified = /^([a-z]+):(.+)$/.exec(name);
+  const harness = qualified?.[1] ?? "claude";
+  const rest = qualified?.[2] ?? name;
+  const root = AGENT_MEMORY_ROOTS.find((candidate) => candidate.harness === harness)?.root;
+  return root === void 0 ? name : `${root}/${rest}`;
+};
+var memoryImport = async (config, args) => {
+  const repoRoot = cwdFacts(process.cwd()).repoRoot;
+  if (repoRoot === null) return fail6("run mend memory import inside the repository's checkout");
+  const claudeDir = claudeMemoryDirFor(repoRoot);
+  const claude = claudeDir === null ? null : scanClaudeMemory(claudeDir);
+  const codex = await scanCodexMemory(repoRoot);
+  for (const note of [...claude?.notes ?? [], ...codex.notes]) say6(dim6(`  ${note}`));
+  const files = [...claude?.files ?? [], ...codex.files];
+  if (files.length === 0) {
+    return fail6(`neither claude nor codex keeps memory for ${repoRoot} on this machine`);
+  }
+  const project2 = await findProject(config, takeFlagValue4(args, "--project"));
+  if (claude !== null && claude.files.length > 0) {
+    say6(
+      `claude memory \xB7 ${claude.dir} \xB7 ${claude.files.length} file${claude.files.length === 1 ? "" : "s"}`
+    );
+  }
+  if (codex.files.length > 0) {
+    say6(
+      `codex memory \xB7 ${codex.home} \xB7 ${codex.summaries} conversation summar${codex.summaries === 1 ? "y" : "ies"} of this repository`
+    );
+  }
+  const dryRun = args.includes("--dry-run");
+  const source = importSourceFor(mendCliHome(), repoRoot, { create: !dryRun });
+  const report = await withSpinner(
+    dryRun ? "planning" : "importing",
+    api(
+      config,
+      "POST",
+      `/projects/${project2.id}/memory/import${dryRun ? "/plan" : ""}`,
+      source === null ? { files } : { files, source }
+    )
+  );
+  say6(
+    `${dryRun ? "would import" : green6("imported")} into ${project2.name} \xB7 ${importReportCounts(report)}`
+  );
+  for (const line of importReportLines(report)) say6(dim6(line));
+  say6(
+    dim6(
+      dryRun ? "--dry-run: nothing written" : "every version replaced is kept \xB7 sessions in the project receive it from the next launch"
+    )
+  );
+};
+var memoryCommand = async (config, args) => {
+  const [verb, ...rest] = args;
+  if (verb === "import") return memoryImport(config, rest);
+  const flags = verb === "show" || verb === "rm" ? rest : args;
+  const project2 = await findProject(config, takeFlagValue4(flags, "--project"));
+  const base = `/projects/${project2.id}/memory`;
+  if (verb === "show" || verb === "rm") {
+    const name = rest.find(
+      (arg, index) => !arg.startsWith("--") && rest[index - 1] !== "--project"
+    );
+    if (name === void 0) return fail6(usageOf(`memory ${verb}`));
+    const query = `?path=${encodeURIComponent(memoryPathOf(name))}`;
+    if (verb === "rm") {
+      const removed = await api(
+        config,
+        "DELETE",
+        `${base}/file${query}`
+      );
+      return say6(
+        removed.removed ? `removed ${name} \xB7 kept as a version` : `${name}: not in memory`
+      );
+    }
+    const file = await api(
+      config,
+      "GET",
+      `${base}/file${query}`
+    );
+    process.stdout.write(
+      file.encoding === "utf8" ? file.contents : Buffer.from(file.contents, "base64")
+    );
+    return;
+  }
+  const view = await api(
+    config,
+    "GET",
+    base
+  );
+  if (view.files.length === 0) {
+    say6(
+      `${project2.name}: no agent memory yet ${dim6("\xB7 mend memory import brings this machine's")}`
+    );
+    return;
+  }
+  const width = Math.max(...view.files.map((file) => file.name.length));
+  for (const file of view.files) {
+    say6(
+      `${file.harness.padEnd(7)} ${file.name.padEnd(width)}  ${kilobytes(file.bytes).padStart(8)}  ${dim6(
+        `${file.updatedAt.slice(0, 16).replace("T", " ")} \xB7 ${file.updatedBySession === null ? "imported" : `session ${file.updatedBySession.slice(0, 8)}`}`
+      )}`
+    );
+  }
+};
+var secretsCommand = async (config, args) => {
+  const [verb, ...rest] = args;
+  if (verb === "add" || verb === "rm") {
+    const given = rest.find((arg, index) => !arg.startsWith("--") && rest[index - 1] !== "--from");
+    if (given === void 0) return fail6(usageOf(`secrets ${verb}`));
+    const resolved = secretFilePathOf(given, os13.homedir());
+    if (resolved.issue !== null) return fail6(resolved.issue);
+    if (verb === "rm") {
+      const removed = await api(
+        config,
+        "DELETE",
+        `/me/secret-files?path=${encodeURIComponent(resolved.path)}`
+      );
+      return say6(
+        removed.removed ? `removed ~/${resolved.path} ${dim6("\xB7 sessions launched from now on do not receive it")}` : `~/${resolved.path}: not kept`
+      );
+    }
+    const from = takeFlagValue4(rest, "--from");
+    let bytes;
+    try {
+      bytes = fs20.readFileSync(from ?? 0);
+    } catch (error) {
+      return fail6(
+        from === null ? `nothing on stdin: pass --from <file> or pipe the content in` : `${from}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    if (bytes.byteLength === 0)
+      return fail6(from === null ? "nothing on stdin" : `${from} is empty`);
+    const saved = await api(config, "PUT", "/me/secret-files", secretFileUploadOf(resolved.path, bytes));
+    say6(
+      `${green6(saved.action)} ~/${saved.file.path} \xB7 ${saved.file.bytes} B ${dim6(
+        "\xB7 sessions launched from now on receive it"
+      )}`
+    );
+    return;
+  }
+  if (verb !== void 0 && verb !== "list") return fail6(usageOf("secrets"));
+  const view = await api(
+    config,
+    "GET",
+    "/me/secret-files"
+  );
+  if (view.files.length === 0) {
+    say6(`no secret files ${dim6("\xB7 mend secrets add <path> --from <file> keeps one")}`);
+    return;
+  }
+  for (const line of secretFileLines(view.files)) say6(line);
+};
 var isProvider = (value) => value === "claude" || value === "codex" || value === "github";
-var readIfExists = (file) => fs17.existsSync(file) ? fs17.readFileSync(file, "utf8") : null;
+var readIfExists = (file) => fs20.existsSync(file) ? fs20.readFileSync(file, "utf8") : null;
 var localCredential = (provider) => {
-  const home = os11.homedir();
+  const home = os13.homedir();
   switch (provider) {
     case "codex":
       return readIfExists(
-        path18.join(process.env["CODEX_HOME"] ?? path18.join(home, ".codex"), "auth.json")
+        path21.join(process.env["CODEX_HOME"] ?? path21.join(home, ".codex"), "auth.json")
       );
     case "claude":
       return readIfExists(
-        path18.join(
-          process.env["CLAUDE_CONFIG_DIR"] ?? path18.join(home, ".claude"),
+        path21.join(
+          process.env["CLAUDE_CONFIG_DIR"] ?? path21.join(home, ".claude"),
           ".credentials.json"
         )
       );
@@ -9152,7 +11097,7 @@ var claudeGrantSecret = () => {
   return read.kind === "missing" ? null : read.secret;
 };
 var doctorBundle = (config, args) => doctorBundleCommand(args, {
-  defaultDir: path18.join(mendCliHome(), "bundles"),
+  defaultDir: path21.join(mendCliHome(), "bundles"),
   now: () => /* @__PURE__ */ new Date(),
   say: say6,
   warn: (line) => process.stderr.write(`${line}
@@ -9215,7 +11160,7 @@ var claudeGrant = async () => {
       fail6("claude: the login completed but Claude still reports no grant in Mend's directory");
       return null;
     }
-    if (status.configDirectory !== null && path18.resolve(status.configDirectory) !== path18.resolve(dir)) {
+    if (status.configDirectory !== null && path21.resolve(status.configDirectory) !== path21.resolve(dir)) {
       fail6(
         `claude: this Claude read ${status.configDirectory} instead of ${dir}, so a separate grant is not possible \u2014 connect the shared one deliberately with --use-my-login`
       );
@@ -9248,7 +11193,7 @@ var claudeGrant = async () => {
       say6(dim6("  your own Claude login still works \xB7 verified"));
     }
     const kept = claudeGrantDir(home);
-    if (fs17.existsSync(kept)) {
+    if (fs20.existsSync(kept)) {
       forgetGrant(kept);
       say6(dim6(`  removed the copy an older mend kept in ${kept} \xB7 the server refreshes the login`));
     }
@@ -9257,8 +11202,38 @@ var claudeGrant = async () => {
     forgetGrant(dir);
   }
 };
+var connectPi = async (config, flags) => {
+  if (flags.includes("--remove")) {
+    const removed = await api(config, "DELETE", "/me/pi-profile");
+    process.stdout.write(removed.removed ? "pi: profile removed\n" : "pi: no profile saved\n");
+    return;
+  }
+  const scan = scanPiProfile(takeFlagValue4(flags, "--dir") ?? piAgentDir());
+  if ("error" in scan) return fail6(scan.error);
+  for (const line of piProfileLines(scan)) say6(line);
+  const issue = validatePiProfile(scan.files);
+  if (issue !== null) return fail6(`pi: ${issue}`);
+  if (flags.includes("--dry-run")) {
+    say6(dim6("  --dry-run: nothing sent"));
+    return;
+  }
+  const saved = await withSpinner(
+    "saving the pi profile",
+    api(
+      config,
+      "PUT",
+      "/me/pi-profile",
+      { files: scan.files }
+    )
+  );
+  process.stdout.write(
+    `pi       profile ${saved.changed ? "saved" : "unchanged"} \xB7 revision ${saved.profile.revision} \xB7 new pi sessions receive it
+`
+  );
+};
 var connectCommand = async (config, args) => {
   const [providerArg, ...flags] = args;
+  if (providerArg === "pi") return connectPi(config, flags);
   if (!isProvider(providerArg)) {
     return fail6(usageOf("connect"));
   }
@@ -9274,12 +11249,12 @@ var connectCommand = async (config, args) => {
   }
   let secret;
   if (flags.includes("--from-stdin")) {
-    secret = fs17.readFileSync(0, "utf8").trim();
+    secret = fs20.readFileSync(0, "utf8").trim();
     if (secret === "") return fail6("nothing on stdin");
   } else if (provider === "codex" && !flags.includes("--use-my-login")) {
     const grant = codexGrant({
       cli: codexCli(),
-      personalAuthJson: readIfExists(path18.join(personalCodexHome(), "auth.json")),
+      personalAuthJson: readIfExists(path21.join(personalCodexHome(), "auth.json")),
       say: say6,
       parent: mendCliHome()
     });
@@ -9329,14 +11304,14 @@ var takeFlagValue4 = (args, flag) => {
   return at !== -1 && args[at + 1] !== void 0 ? String(args[at + 1]) : null;
 };
 var saveCliConfig = (next) => {
-  fs17.mkdirSync(path18.dirname(CONFIG_PATH), { recursive: true, mode: 448 });
-  fs17.writeFileSync(
+  fs20.mkdirSync(path21.dirname(CONFIG_PATH), { recursive: true, mode: 448 });
+  fs20.writeFileSync(
     CONFIG_PATH,
     `${JSON.stringify({ url: next.url, token: next.token, deviceId: next.deviceId }, null, 2)}
 `,
     { mode: 384 }
   );
-  fs17.chmodSync(CONFIG_PATH, 384);
+  fs20.chmodSync(CONFIG_PATH, 384);
 };
 var login = async (config, args) => {
   await loginCommand(args, {
@@ -9349,7 +11324,7 @@ var login = async (config, args) => {
   });
 };
 var logout = async (config) => {
-  if (!fs17.existsSync(CONFIG_PATH) && config.token === null) {
+  if (!fs20.existsSync(CONFIG_PATH) && config.token === null) {
     say6(dim6("nothing saved \u2014 already signed out"));
     return;
   }
@@ -9402,8 +11377,8 @@ var uninstallCommand = async (config, args) => {
   const runtime = {
     server,
     cliHome: mendCliHome(),
-    sshConfigFile: path18.join(os11.homedir(), ".ssh", "config"),
-    signedIn: config.token === null || !fs17.existsSync(CONFIG_PATH) ? null : { url: config.url, deviceId: config.deviceId },
+    sshConfigFile: path21.join(os13.homedir(), ".ssh", "config"),
+    signedIn: config.token === null || !fs20.existsSync(CONFIG_PATH) ? null : { url: config.url, deviceId: config.deviceId },
     revokeDevice: async () => {
       if (config.deviceId === null) return "no device id saved";
       try {
@@ -9467,7 +11442,7 @@ var keysShare = async (config) => {
     return fail6("SSH_AUTH_SOCK is not set \u2014 start (or plug in) your ssh-agent first");
   }
   await shareAgent({
-    url: () => socketUrl(config, "keys-bridge", { host: os11.hostname() }),
+    url: () => socketUrl(config, "keys-bridge", { host: os13.hostname() }),
     agentSock,
     signal: new AbortController().signal,
     onEvent: (event) => {
@@ -9597,7 +11572,7 @@ ${usageOf("dotfiles repo")}`);
 var dotfilesSync = async (config, args) => {
   const all = args.includes("--all");
   const requestedPaths = args.filter((arg) => !arg.startsWith("--"));
-  const home = os11.homedir();
+  const home = os13.homedir();
   if (!all && requestedPaths.length === 0) {
     const found = scanDotfileCandidates(home);
     if (found.length === 0) {
@@ -9624,13 +11599,13 @@ var dotfilesSync = async (config, args) => {
   if ("error" in read) return fail6(read.error);
   const result = await api(config, "POST", "/dotfiles/snapshot", {
     files: read.files,
-    source: os11.hostname(),
+    source: os13.hostname(),
     merge: false
   });
   const snapshot = result.snapshot;
   if (snapshot === null) return fail6("the server accepted the sync but reports no snapshot");
   say6(
-    `${green6("synced")} ${snapshot.files.length} file${snapshot.files.length === 1 ? "" : "s"} from ${os11.hostname()} \xB7 ${dim6(snapshot.sha.slice(0, 7))} ${dim6("\u2014 applies from the next session launch")}`
+    `${green6("synced")} ${snapshot.files.length} file${snapshot.files.length === 1 ? "" : "s"} from ${os13.hostname()} \xB7 ${dim6(snapshot.sha.slice(0, 7))} ${dim6("\u2014 applies from the next session launch")}`
   );
 };
 var envLoad = async (config, args) => {
@@ -9644,10 +11619,10 @@ var envLoad = async (config, args) => {
   const positional = args.filter(
     (arg, i) => !arg.startsWith("--") && args[i - 1] !== "--project" && !consumed.has(i)
   );
-  const file = path18.resolve(positional[0] ?? ".env");
+  const file = path21.resolve(positional[0] ?? ".env");
   let contents;
   try {
-    contents = fs17.readFileSync(file, "utf8");
+    contents = fs20.readFileSync(file, "utf8");
   } catch {
     return fail6(`cannot read ${file} \u2014 pass a path: mend env load path/to/.env`);
   }
@@ -9663,10 +11638,10 @@ var envLoad = async (config, args) => {
     { contents, allSecret, secretNames }
   );
   if (report.loaded.length === 0 && report.rejected.length === 0 && report.malformedLines.length === 0) {
-    say6(dim6(`${path18.basename(file)} has no variables`));
+    say6(dim6(`${path21.basename(file)} has no variables`));
     return;
   }
-  say6(`${green6("\u2713")} loaded ${path18.basename(file)} into ${project2.name}`);
+  say6(`${green6("\u2713")} loaded ${path21.basename(file)} into ${project2.name}`);
   for (const line of formatLoadReport(report, { dim: dim6, warn: amber2 })) say6(line);
   const plaintextUrls = report.loaded.filter(
     (entry) => entry.lane === "configuration" && /_(URL|URI|DSN)$/.test(entry.name)
@@ -9857,7 +11832,7 @@ var skillsList = async (config, args) => {
 };
 var skillsPush = async (config, args) => {
   const dirFlag = takeFlagValue4(args, "--dir");
-  const root = dirFlag === null ? path18.join(os11.homedir(), DEFAULT_SKILLS_DIR) : path18.resolve(dirFlag);
+  const root = dirFlag === null ? path21.join(os13.homedir(), DEFAULT_SKILLS_DIR) : path21.resolve(dirFlag);
   const scanned = scanSkillLibrary(root);
   if ("error" in scanned) return fail6(scanned.error);
   for (const note of scanned.notes) say6(dim6(`  ${note.skill}: ${note.message}`));
@@ -9921,7 +11896,7 @@ _mend() {
   local -a commands
   commands=(
     'adopt:adopt a repository into the store'
-    'codex:new session + codex' 'claude:new session + claude' 'opencode:new session + opencode'
+    'codex:new session + codex' 'claude:new session + claude' 'opencode:new session + opencode' 'pi:new session + pi'
     'run:new session + arbitrary command'
     'attach:reattach to a running session' 'stop:stop the agent \u2014 record and review remain'
     'shell:open a shell in a live session workspace'
@@ -9931,9 +11906,10 @@ _mend() {
     'keys:the machine Mend deploy key \u2014 init, show, share'
     'git-author:the name and email your workspaces commit as'
     'skills:skill libraries \u2014 list, push'
+    'memory:what the agents remember about a project \u2014 list, show, rm, import'
     'accounts:your connected accounts on the platform'
     'pair:pair a phone or a second machine' 'doctor:read-only checklist of this setup'
-    'connect:send this machine'"'"'s claude/codex/github credential to the platform'
+    'connect:send this machine'"'"'s claude/codex/github credential, or your pi setup'
     'continue:resume with the pending follow-up' 'resume:rejoin a settled session'
     'rejoin:attach if live, otherwise resume'
     'land:push a session change to origin and open its pull request'
@@ -9952,7 +11928,7 @@ _mend() {
       else
         case $words[3] in
           setup) compadd -- --version --assets-dir --offline --context --port --ssh-port --bind --url --origin --docker-socket ;;
-          upgrade) compadd -- --version --assets-dir --offline ;;
+          upgrade) compadd -- --version --assets-dir --offline --from-preview ;;
           start|restart) compadd -- --offline ;;
           logs) compadd -- --tail ;;
         esac
@@ -9970,7 +11946,7 @@ _mend "$@"
 var BASH_COMPLETIONS = `_mend() {
   local cur=\${COMP_WORDS[COMP_CWORD]}
   if [ "$COMP_CWORD" -eq 1 ]; then
-    COMPREPLY=( $(compgen -W "adopt codex claude opencode run attach stop shell service server uninstall keys git-author skills pair doctor continue resume rejoin land pull refresh projects sessions status ui help" -- "$cur") )
+    COMPREPLY=( $(compgen -W "adopt codex claude opencode pi run attach stop shell service server uninstall keys git-author skills memory connect pair doctor continue resume rejoin land pull refresh projects sessions status ui help" -- "$cur") )
     return
   fi
   case \${COMP_WORDS[1]} in
@@ -9981,7 +11957,7 @@ var BASH_COMPLETIONS = `_mend() {
       else
         case \${COMP_WORDS[2]} in
           setup) options="--version --assets-dir --offline --context --port --ssh-port --bind --url --origin --docker-socket" ;;
-          upgrade) options="--version --assets-dir --offline" ;;
+          upgrade) options="--version --assets-dir --offline --from-preview" ;;
           start|restart) options="--offline" ;;
           logs) options="--tail" ;;
         esac
@@ -10128,7 +12104,7 @@ var agentLiveIn = (detail, session) => agentIsLive(
 var resumeCommand = async (config, args) => {
   const withFlag = args.indexOf("--with");
   const withHarness = withFlag !== -1 && args[withFlag + 1] !== void 0 ? String(args[withFlag + 1]) : null;
-  const prefix = args.find((a, i) => !a.startsWith("--") && i !== withFlag + 1);
+  const prefix = firstPositional(args, ["--with"]);
   const project2 = await findProject(config, null);
   const detail = await api(config, "GET", `/projects/${project2.id}`);
   const match = prefix === void 0 ? detail.sessions.find((s) => !agentLiveIn(detail, s)) : detail.sessions.find((s) => s.id.startsWith(prefix));
@@ -10178,7 +12154,7 @@ var resumeForRejoin = async (config, sessionId, label) => {
 var rejoinCommand = async (config, args) => {
   const harnessFlag = args.indexOf("--harness");
   const harness = harnessFlag !== -1 && args[harnessFlag + 1] !== void 0 ? String(args[harnessFlag + 1]) : null;
-  const prefix = args.find((arg, index) => !arg.startsWith("--") && index !== harnessFlag + 1);
+  const prefix = firstPositional(args, ["--harness"]);
   const tunnels = attachTunnels(config, args.includes("--no-tunnel"));
   const project2 = await findProject(config, null);
   const detail = await api(config, "GET", `/projects/${project2.id}`);
@@ -10309,10 +12285,20 @@ var printSessionRow = (row) => {
   if (annotation !== void 0 && annotation.pendingFollowUp)
     facts.push(amber2("follow-up pending"));
   const base = session.baseRef === null ? session.baseSha.slice(0, 12) : session.baseRef;
+  const model = session.model === null || session.model === void 0 ? "" : ` \xB7 ${session.model}${session.effort === null || session.effort === void 0 ? "" : ` \xB7 ${session.effort}`}`;
   say6(
-    `${session.harness.padEnd(8)}  ${dim6(session.id.slice(0, 8))}  ${live ? green6(status) : dim6(status)}  ${row.projectName}  ${dim6(`${session.branch} \xB7 base ${base}`)}${facts.length > 0 ? `  ${facts.join(dim6(" \xB7 "))}` : ""}`
+    `${session.harness.padEnd(8)}  ${dim6(session.id.slice(0, 8))}  ${live ? green6(status) : dim6(status)}  ${row.projectName}  ${dim6(`${session.branch} \xB7 base ${base}${model}`)}${facts.length > 0 ? `  ${facts.join(dim6(" \xB7 "))}` : ""}`
   );
 };
+var modelsCommand = async (config, args) => {
+  const catalogs = await api(
+    config,
+    "GET",
+    "/harnesses/models"
+  );
+  if (args.includes("--json")) return say6(modelCatalogJson(catalogs));
+  for (const line of modelCatalogLines(catalogs, dim6)) say6(line);
+};
 var sessionsCommand = async (config, args) => {
   const all = args.includes("--all");
   if (args.includes("--json=v2")) {
@@ -10478,6 +12464,18 @@ var buildWorktreesJson = async (config, projectName) => {
   return { version: 2, worktrees };
 };
 var worktreesCommand = async (config, args) => {
+  if (args[0] === "rm") {
+    return worktreesRmCommand(
+      {
+        request: (method, route, body) => request(config, method, route, body),
+        listWorktrees: async (project2) => (await buildWorktreesJson(config, project2)).worktrees,
+        liveStatuses: ACTIVE_STATUSES,
+        say: say6,
+        fail: fail6
+      },
+      args.slice(1)
+    );
+  }
   const json2 = args.includes("--json");
   const projectFlag = args.indexOf("--project");
   const projectName = projectFlag !== -1 && args[projectFlag + 1] !== void 0 ? String(args[projectFlag + 1]) : null;
@@ -10539,7 +12537,7 @@ var dashboard = async (config, options = {}) => {
     );
     process.exit(rerun.status ?? 0);
   }
-  const { runDashboard } = await import("./dashboard-MGR4YUFD.js");
+  const { runDashboard } = await import("./dashboard-P73HKQOT.js");
   const agentShare = await startShareIfBridge(config);
   const tunnels = options.noTunnel === true || serverIsLocal(config) ? null : createServiceTunnels({
     listServices: () => fetchServices(config),
@@ -10573,7 +12571,7 @@ var startShareIfBridge = async (config) => {
   }
   if (access.mode !== "bridge") return null;
   return startAgentShare({
-    url: () => socketUrl(config, "keys-bridge", { host: os11.hostname() }),
+    url: () => socketUrl(config, "keys-bridge", { host: os13.hostname() }),
     agentSock
   });
 };
@@ -10613,10 +12611,10 @@ var manCommand = (words) => {
   }
   const version = cliVersion();
   const page = doc === null ? renderManIndex(version) : renderManPage(doc, version);
-  const file = path18.join(os11.tmpdir(), `mend-man-${process.pid}-${manFileName(doc)}`);
-  fs17.writeFileSync(file, page);
+  const file = path21.join(os13.tmpdir(), `mend-man-${process.pid}-${manFileName(doc)}`);
+  fs20.writeFileSync(file, page);
   const result = spawnSync6("man", ["-l", file], { stdio: "inherit" });
-  fs17.rmSync(file, { force: true });
+  fs20.rmSync(file, { force: true });
   if (result.error !== void 0 || result.status !== 0) {
     say6(doc === null ? renderIndex() : renderCommand(doc));
   }
@@ -10640,6 +12638,7 @@ var main = async () => {
     case "codex":
     case "claude":
     case "opencode":
+    case "pi":
     case "run":
       return withAgentShare(config, () => launch(config, command, rest));
     case "attach":
@@ -10664,6 +12663,10 @@ var main = async () => {
       return dotfilesCommand(config, rest);
     case "skills":
       return skillsCommand(config, rest);
+    case "memory":
+      return memoryCommand(config, rest);
+    case "secrets":
+      return secretsCommand(config, rest);
     case "accounts":
       return accountsCommand(config);
     case "connect":
@@ -10717,6 +12720,8 @@ var main = async () => {
     case "sessions":
     case "status":
       return sessionsCommand(config, rest);
+    case "models":
+      return modelsCommand(config, rest);
     case "worktrees":
       return worktreesCommand(config, rest);
     case void 0: