mcproc 0.14.2 → 0.15.0

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli/program.ts
-import fs19 from "fs";
+import fs20 from "fs";
 import { Command, Option } from "commander";
 
 // src/version.ts
@@ -259,9 +259,9 @@ function ensureOk(res, host, what) {
 }
 
 // src/runtime/unpack.ts
-import fs5 from "fs";
-import os3 from "os";
-import path7 from "path";
+import fs7 from "fs";
+import os5 from "os";
+import path10 from "path";
 
 // src/core/pm2.ts
 import { createRequire as createRequire2 } from "module";
@@ -459,7 +459,8 @@ async function resolvePm2Bin(host, transport) {
 }
 
 // src/core/resolve.ts
-import path4 from "path";
+import os2 from "os";
+import path7 from "path";
 
 // src/core/manifest.ts
 import fs2 from "fs";
@@ -1553,6 +1554,166 @@ function loadManifest(startDir) {
   );
 }
 
+// src/core/registry.ts
+import fs4 from "fs";
+import path6 from "path";
+
+// src/core/slots.ts
+import crypto from "crypto";
+import fs3 from "fs";
+import path4 from "path";
+function registryKey(baseProject, repo) {
+  return `${baseProject}-${crypto.createHash("sha256").update(realOf(repo)).digest("hex").slice(0, 8)}`;
+}
+function registryPath(stateDir2, baseProject, repo) {
+  return path4.join(stateDir2, "slots", `${registryKey(baseProject, repo)}.json`);
+}
+function emptyRegistry(repo) {
+  return { repo, slots: {} };
+}
+function readRegistry(file) {
+  if (!fs3.existsSync(file)) return null;
+  return JSON.parse(fs3.readFileSync(file, "utf8"));
+}
+function writeRegistry(file, r) {
+  fs3.mkdirSync(path4.dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs3.writeFileSync(tmp, JSON.stringify(r, null, 2));
+  fs3.renameSync(tmp, file);
+}
+function withMain(r, entry) {
+  return { ...r, slots: { ...r.slots, "0": entry } };
+}
+function claimSlot(r, opts) {
+  if (opts.want !== void 0) {
+    if (opts.want < 1 || opts.want > opts.max)
+      throw new McprocError(
+        "BAD_ARGUMENT",
+        `slot ${opts.want} is outside 1..${opts.max} (slot 0 is the main checkout)`
+      );
+    if (Object.hasOwn(r.slots, String(opts.want)))
+      throw new McprocError(
+        "SLOT_TAKEN",
+        `slot ${opts.want} is taken by ${r.slots[String(opts.want)].path}`,
+        { hint: "Pick another slot, or remove that worktree first." }
+      );
+    return {
+      registry: { ...r, slots: { ...r.slots, [opts.want]: opts.entry } },
+      slot: opts.want
+    };
+  }
+  for (let s = 1; s <= opts.max; s++)
+    if (!Object.hasOwn(r.slots, String(s)))
+      return {
+        registry: { ...r, slots: { ...r.slots, [s]: opts.entry } },
+        slot: s
+      };
+  throw new McprocError(
+    "NO_FREE_SLOT",
+    `all ${opts.max} worktree slots of ${r.repo} are taken`,
+    {
+      hint: "Remove a worktree (worktree remove), or raise worktree.slots in the manifest."
+    }
+  );
+}
+function releaseSlot(r, slot) {
+  const slots = { ...r.slots };
+  delete slots[String(slot)];
+  return { ...r, slots };
+}
+function realOf(p) {
+  try {
+    return fs3.realpathSync(p);
+  } catch {
+    return path4.resolve(p);
+  }
+}
+function reclaimGone(r, exists) {
+  const freed = [];
+  let out = r;
+  for (const [k, e] of Object.entries(r.slots)) {
+    if (k === "0" || exists(realOf(e.path))) continue;
+    out = releaseSlot(out, Number(k));
+    freed.push(Number(k));
+  }
+  return { registry: out, freed: freed.sort((a, b) => a - b) };
+}
+function siblingsOf(r, root) {
+  return Object.entries(r.slots).filter(([, e]) => realOf(e.path) !== realOf(root)).map(([k, entry]) => ({ slot: Number(k), entry })).sort((a, b) => a.slot - b.slot);
+}
+
+// src/core/state.ts
+import os from "os";
+import path5 from "path";
+function stateDir(env = process.env) {
+  if (env.MCPROC_STATE_DIR) return path5.resolve(env.MCPROC_STATE_DIR);
+  return path5.join(
+    env.XDG_STATE_HOME || path5.join(os.homedir(), ".local", "state"),
+    "mcproc"
+  );
+}
+
+// src/core/registry.ts
+var projectsDir = (dir) => path6.join(dir, "projects");
+function projectFile(dir, project, root) {
+  return path6.join(projectsDir(dir), `${registryKey(project, root)}.json`);
+}
+function recordProject(m, dir = stateDir()) {
+  try {
+    const file = projectFile(dir, m.project, m.root);
+    const text = JSON.stringify(
+      {
+        project: m.project,
+        root: m.root,
+        manifest: m.path
+      },
+      null,
+      2
+    );
+    try {
+      if (fs4.readFileSync(file, "utf8") === text) return;
+    } catch {
+    }
+    fs4.mkdirSync(path6.dirname(file), { recursive: true });
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs4.writeFileSync(tmp, text);
+    fs4.renameSync(tmp, file);
+  } catch {
+  }
+}
+function forgetProject(project, root, dir = stateDir()) {
+  try {
+    fs4.rmSync(projectFile(dir, project, root), { force: true });
+  } catch {
+  }
+}
+function isEntry(v) {
+  const e = v;
+  return typeof e === "object" && e !== null && typeof e.project === "string" && typeof e.root === "string" && typeof e.manifest === "string";
+}
+function listProjects(dir = stateDir()) {
+  let names;
+  try {
+    names = fs4.readdirSync(projectsDir(dir)).filter((n) => n.endsWith(".json"));
+  } catch (e) {
+    const code = e.code;
+    return { entries: [], error: code === "ENOENT" ? null : String(code ?? e) };
+  }
+  const entries = [];
+  for (const n of names.sort()) {
+    const file = path6.join(projectsDir(dir), n);
+    try {
+      const e = JSON.parse(fs4.readFileSync(file, "utf8"));
+      if (!isEntry(e)) continue;
+      if (fs4.existsSync(e.manifest)) entries.push(e);
+      else if (fs4.existsSync(path6.dirname(e.root)))
+        fs4.rmSync(file, { force: true });
+    } catch {
+    }
+  }
+  return { entries, error: null };
+}
+
 // src/core/urlcheck.ts
 import http from "http";
 import https from "https";
@@ -1878,7 +2039,18 @@ function reasonWord(reason) {
 var MAX_PM2_HOME = 90;
 function resolveProjectDir(explicit, roots = [], env = process.env) {
   const pick = explicit || env.MCPROC_PROJECT || env.CLAUDE_PROJECT_DIR || roots[0] || process.cwd();
-  return path4.resolve(pick);
+  return path7.resolve(pick);
+}
+function bareLocalHost() {
+  return {
+    name: "local",
+    local: true,
+    ssh_args: [],
+    cwd: os2.homedir(),
+    readonly: false,
+    shell: parseShell(DEFAULT_SHELL),
+    env: {}
+  };
 }
 function pickHost(m, name2 = "local") {
   const h = Object.hasOwn(m.hosts, name2) ? m.hosts[name2] : void 0;
@@ -1915,6 +2087,7 @@ function assertApp(m, name2) {
 }
 function prepare(opts) {
   const manifest = loadManifest(resolveProjectDir(opts.project, opts.roots));
+  recordProject(manifest);
   return { manifest, host: pickHost(manifest, opts.host) };
 }
 var cache = /* @__PURE__ */ new Map();
@@ -1948,30 +2121,39 @@ async function connect(prep, opts = {}) {
     hereCheck: opts.hereCheck ?? checkHere
   };
 }
+async function connectHost(host, opts = {}) {
+  const transport = createTransport(host, opts.spawner);
+  const resolution = await resolvePm2Bin(host, transport);
+  return {
+    host,
+    transport,
+    pm2: new Pm2Client(transport, host, resolution.bin, host.pm2_home)
+  };
+}
 
 // src/runtime/bundle.ts
 import { execFileSync } from "child_process";
 import { createHash } from "crypto";
-import fs3 from "fs";
-import os from "os";
-import path5 from "path";
+import fs5 from "fs";
+import os3 from "os";
+import path8 from "path";
 import { fileURLToPath } from "url";
 var sha256 = (b) => createHash("sha256").update(b).digest("hex");
 var readJson = (p) => (
   // biome-ignore lint/suspicious/noExplicitAny: package.json files are untyped data, probed field by field
-  JSON.parse(fs3.readFileSync(p, "utf8"))
+  JSON.parse(fs5.readFileSync(p, "utf8"))
 );
-function findPackageRoot(from = path5.dirname(fileURLToPath(import.meta.url))) {
-  let dir = path5.resolve(from);
+function findPackageRoot(from = path8.dirname(fileURLToPath(import.meta.url))) {
+  let dir = path8.resolve(from);
   for (; ; ) {
-    const p = path5.join(dir, "package.json");
-    if (fs3.existsSync(p)) {
+    const p = path8.join(dir, "package.json");
+    if (fs5.existsSync(p)) {
       try {
         if (readJson(p).name === "mcproc") return dir;
       } catch {
       }
     }
-    const parent = path5.dirname(dir);
+    const parent = path8.dirname(dir);
     if (parent === dir)
       throw new McprocError(
         "BUNDLE_INVALID",
@@ -1982,12 +2164,12 @@ function findPackageRoot(from = path5.dirname(fileURLToPath(import.meta.url))) {
 }
 function lockfileHash(root) {
   return sha256(
-    fs3.readFileSync(path5.join(root, "runtime", "package-lock.json"))
+    fs5.readFileSync(path8.join(root, "runtime", "package-lock.json"))
   );
 }
 function defaultPm2CacheDir(env = process.env) {
-  return path5.join(
-    env.XDG_CACHE_HOME || path5.join(os.homedir(), ".cache"),
+  return path8.join(
+    env.XDG_CACHE_HOME || path8.join(os3.homedir(), ".cache"),
     "mcproc",
     "pm2"
   );
@@ -2013,31 +2195,31 @@ async function ensurePm2Bundle(opts = {}) {
   const root = opts.root ?? findPackageRoot();
   const cacheDir = opts.cacheDir ?? defaultPm2CacheDir();
   const run = opts.run ?? defaultRunner;
-  const pin = readJson(path5.join(root, "package.json")).dependencies?.pm2 ?? "";
+  const pin = readJson(path8.join(root, "package.json")).dependencies?.pm2 ?? "";
   if (!/^\d+\.\d+\.\d+$/.test(pin))
     throw new McprocError(
       "BUNDLE_INVALID",
       `pm2 must be pinned to an exact version in mcproc's package.json, got "${pin}"`
     );
-  const runtimePin = readJson(path5.join(root, "runtime", "package.json")).dependencies?.pm2 ?? "";
+  const runtimePin = readJson(path8.join(root, "runtime", "package.json")).dependencies?.pm2 ?? "";
   if (runtimePin !== pin)
     throw new McprocError(
       "BUNDLE_INVALID",
       `runtime/package.json pins pm2 ${runtimePin}, package.json pins ${pin}`
     );
   const lockSha = lockfileHash(root);
-  const target = path5.join(cacheDir, `pm2-${pin}-${lockSha.slice(0, 12)}.tgz`);
+  const target = path8.join(cacheDir, `pm2-${pin}-${lockSha.slice(0, 12)}.tgz`);
   const sidecar = `${target}.json`;
-  if (!opts.force && fs3.existsSync(target) && fs3.existsSync(sidecar)) {
+  if (!opts.force && fs5.existsSync(target) && fs5.existsSync(sidecar)) {
     const meta = readJson(sidecar);
-    const data = fs3.readFileSync(target);
+    const data = fs5.readFileSync(target);
     if (meta.pm2 === pin && meta.lock_sha256 === lockSha && sha256(data) === meta.sha256)
       return { version: pin, sha256: meta.sha256, data, path: target };
   }
-  const stage = fs3.mkdtempSync(path5.join(os.tmpdir(), "mcproc-pm2-"));
+  const stage = fs5.mkdtempSync(path8.join(os3.tmpdir(), "mcproc-pm2-"));
   try {
     for (const f of ["package.json", "package-lock.json"])
-      fs3.copyFileSync(path5.join(root, "runtime", f), path5.join(stage, f));
+      fs5.copyFileSync(path8.join(root, "runtime", f), path8.join(stage, f));
     try {
       run(
         "npm",
@@ -2054,14 +2236,14 @@ async function ensurePm2Bundle(opts = {}) {
       );
     }
     const got = readJson(
-      path5.join(stage, "node_modules", "pm2", "package.json")
+      path8.join(stage, "node_modules", "pm2", "package.json")
     ).version;
     if (got !== pin)
       throw new McprocError(
         "BUNDLE_INVALID",
         `npm installed pm2 ${got}, expected ${pin}`
       );
-    fs3.rmSync(path5.join(stage, "node_modules", ".package-lock.json"), {
+    fs5.rmSync(path8.join(stage, "node_modules", ".package-lock.json"), {
       force: true
     });
     const tgz = execFileSync(
@@ -2069,9 +2251,9 @@ async function ensurePm2Bundle(opts = {}) {
       [...tarFlags(), "-czf", "-", "node_modules"],
       { cwd: stage, maxBuffer: 1 << 30 }
     );
-    fs3.mkdirSync(cacheDir, { recursive: true });
-    fs3.writeFileSync(`${target}.part`, tgz);
-    fs3.renameSync(`${target}.part`, target);
+    fs5.mkdirSync(cacheDir, { recursive: true });
+    fs5.writeFileSync(`${target}.part`, tgz);
+    fs5.renameSync(`${target}.part`, target);
     const meta = {
       pm2: pin,
       sha256: sha256(tgz),
@@ -2079,11 +2261,11 @@ async function ensurePm2Bundle(opts = {}) {
       lock_sha256: lockSha,
       built_at: (/* @__PURE__ */ new Date()).toISOString()
     };
-    fs3.writeFileSync(sidecar, `${JSON.stringify(meta, null, 2)}
+    fs5.writeFileSync(sidecar, `${JSON.stringify(meta, null, 2)}
 `);
     return { version: pin, sha256: meta.sha256, data: tgz, path: target };
   } finally {
-    fs3.rmSync(stage, { recursive: true, force: true });
+    fs5.rmSync(stage, { recursive: true, force: true });
   }
 }
 
@@ -2240,16 +2422,16 @@ ${original}`;
 }
 
 // src/runtime/node-dist.ts
-import fs4 from "fs";
-import os2 from "os";
-import path6 from "path";
+import fs6 from "fs";
+import os4 from "os";
+import path9 from "path";
 import { createHash as createHash2 } from "crypto";
 var defaultFetcher = (url) => fetch(url, {
   signal: AbortSignal.timeout(url.endsWith(".tar.gz") ? 6e5 : 3e4)
 });
 function defaultCacheDir(env = process.env) {
-  return path6.join(
-    env.XDG_CACHE_HOME || path6.join(os2.homedir(), ".cache"),
+  return path9.join(
+    env.XDG_CACHE_HOME || path9.join(os4.homedir(), ".cache"),
     "mcproc",
     "node"
   );
@@ -2285,7 +2467,7 @@ async function getBytes(fetcher, url) {
 function cachedVersions(cacheDir, platform) {
   let names = [];
   try {
-    names = fs4.readdirSync(cacheDir);
+    names = fs6.readdirSync(cacheDir);
   } catch {
     return [];
   }
@@ -2322,11 +2504,11 @@ async function fetchNodeTarball(version, platform, opts = {}) {
   const fetcher = opts.fetcher ?? defaultFetcher;
   const cacheDir = opts.cacheDir ?? defaultCacheDir();
   const file = nodeDistFile(version, platform);
-  const target = path6.join(cacheDir, file);
+  const target = path9.join(cacheDir, file);
   const sidecar = `${target}.sha256`;
-  if (fs4.existsSync(target) && fs4.existsSync(sidecar)) {
-    const want2 = fs4.readFileSync(sidecar, "utf8").trim();
-    const data2 = fs4.readFileSync(target);
+  if (fs6.existsSync(target) && fs6.existsSync(sidecar)) {
+    const want2 = fs6.readFileSync(sidecar, "utf8").trim();
+    const data2 = fs6.readFileSync(target);
     if (sha2562(data2) === want2)
       return {
         version,
@@ -2356,10 +2538,10 @@ async function fetchNodeTarball(version, platform, opts = {}) {
       `checksum mismatch for ${file}: SHASUMS256 says ${want}, downloaded ${got}`,
       { hint: HINT }
     );
-  fs4.mkdirSync(cacheDir, { recursive: true });
-  fs4.writeFileSync(`${target}.part`, data);
-  fs4.renameSync(`${target}.part`, target);
-  fs4.writeFileSync(sidecar, `${want}
+  fs6.mkdirSync(cacheDir, { recursive: true });
+  fs6.writeFileSync(`${target}.part`, data);
+  fs6.renameSync(`${target}.part`, target);
+  fs6.writeFileSync(sidecar, `${want}
 `);
   return {
     version,
@@ -2437,9 +2619,9 @@ function defaultUnpackDeps() {
     nodeVersion: (requested, platform) => resolveNodeVersion(requested, platform),
     nodeTarball: async (version, platform) => {
       const t = await fetchNodeTarball(version, platform);
-      return { data: fs5.readFileSync(t.path), sha256: t.sha256 };
+      return { data: fs7.readFileSync(t.path), sha256: t.sha256 };
     },
-    hostname: () => os3.hostname(),
+    hostname: () => os5.hostname(),
     now: () => /* @__PURE__ */ new Date()
   };
 }
@@ -2464,8 +2646,8 @@ async function unpack(target, opts, deps2) {
     }
     return res;
   };
-  const dotDir = path7.posix.join(host.cwd, ".mcproc");
-  const remoteManifest = path7.posix.join(dotDir, "mcproc.yaml");
+  const dotDir = path10.posix.join(host.cwd, ".mcproc");
+  const remoteManifest = path10.posix.join(dotDir, "mcproc.yaml");
   const pr = ensureOk(
     await transport.exec(unpackProbeScript(rt, remoteManifest), { env }),
     host,
@@ -2584,18 +2766,18 @@ async function unpack(target, opts, deps2) {
         `mkdir -p ${shq(`${dotDir}/.generated`)} && { [ -e ${shq(gi)} ] || printf '*\\n' > ${shq(gi)}; } && cat > ${shq(remoteManifest)}`,
         {
           stdin: manifestCopy(
-            fs5.readFileSync(manifest.path, "utf8"),
+            fs7.readFileSync(manifest.path, "utf8"),
             deps2.hostname(),
             deps2.now()
           )
         }
       );
-      const readme = path7.join(manifest.root, ".mcproc", "README.md");
-      if (fs5.existsSync(readme))
+      const readme = path10.join(manifest.root, ".mcproc", "README.md");
+      if (fs7.existsSync(readme))
         await run(
           "readme copy",
           `[ -e ${shq(`${dotDir}/README.md`)} ] || cat > ${shq(`${dotDir}/README.md`)}`,
-          { stdin: fs5.readFileSync(readme, "utf8") }
+          { stdin: fs7.readFileSync(readme, "utf8") }
         );
       manifestState = "written";
     }
@@ -2631,7 +2813,7 @@ async function unpack(target, opts, deps2) {
 }
 
 // src/core/leases/view.ts
-import fs8 from "fs";
+import fs10 from "fs";
 
 // src/core/memory.ts
 var KB = 1024;
@@ -2676,33 +2858,22 @@ async function readHostMemory(transport, host) {
   return i < 0 ? null : parseMeminfo(res.stdout.slice(i + MARK.MEM.length));
 }
 
-// src/core/state.ts
-import os4 from "os";
-import path8 from "path";
-function stateDir(env = process.env) {
-  if (env.MCPROC_STATE_DIR) return path8.resolve(env.MCPROC_STATE_DIR);
-  return path8.join(
-    env.XDG_STATE_HOME || path8.join(os4.homedir(), ".local", "state"),
-    "mcproc"
-  );
-}
-
 // src/core/leases/ensure.ts
-import fs7 from "fs";
-import path11 from "path";
+import fs9 from "fs";
+import path13 from "path";
 
 // src/core/ecosystem.ts
-import path9 from "path";
+import path11 from "path";
 var LOG_STAMP = "YYYY-MM-DDTHH:mm:ss.SSS";
 var STOP_TRAP = "trap 'exit 130' INT; trap 'exit 143' TERM; ";
 function appCwd(host, app) {
-  return path9.posix.resolve(host.cwd, app.cwd);
+  return path11.posix.resolve(host.cwd, app.cwd);
 }
 function generatedDir(host) {
-  return path9.posix.join(host.cwd, ".mcproc", ".generated");
+  return path11.posix.join(host.cwd, ".mcproc", ".generated");
 }
 function ecosystemPath(host) {
-  return path9.posix.join(generatedDir(host), "ecosystem.json");
+  return path11.posix.join(generatedDir(host), "ecosystem.json");
 }
 function buildEcosystem(m, host) {
   const apps = Object.values(m.apps).map((app) => {
@@ -2732,10 +2903,10 @@ function buildEcosystem(m, host) {
 }
 
 // src/core/leases/store.ts
-import crypto from "crypto";
-import fs6 from "fs";
-import os5 from "os";
-import path10 from "path";
+import crypto2 from "crypto";
+import fs8 from "fs";
+import os6 from "os";
+import path12 from "path";
 var ALLOWED = {
   pending: ["starting", "running", "cancelled"],
   starting: ["running", "failed", "cancelled"],
@@ -2776,7 +2947,7 @@ function parseHeld(raw) {
 }
 function readHeld(file) {
   try {
-    return parseHeld(fs6.readFileSync(file, "utf8"));
+    return parseHeld(fs8.readFileSync(file, "utf8"));
   } catch {
     return null;
   }
@@ -2791,13 +2962,13 @@ var LeaseStore = class {
    * `beforeUnlink` (tests only) runs while a breaker holds the break guard, before the re-read that decides the unlink.
    */
   constructor(stateDir2, deps2 = {}) {
-    this.dir = path10.join(stateDir2, "leases");
+    this.dir = path12.join(stateDir2, "leases");
     this.now = deps2.now ?? (() => Date.now());
     this.pid = deps2.pid ?? process.pid;
     this.beforeUnlink = deps2.beforeUnlink;
   }
   file(l) {
-    return path10.join(
+    return path12.join(
       this.dir,
       `${String(l.seq).padStart(6, "0")}-${l.id}.json`
     );
@@ -2806,11 +2977,11 @@ var LeaseStore = class {
     return new Date(this.now()).toISOString();
   }
   write(l) {
-    fs6.mkdirSync(this.dir, { recursive: true });
+    fs8.mkdirSync(this.dir, { recursive: true });
     const f = this.file(l);
     const tmp = `${f}.${this.pid}.tmp`;
-    fs6.writeFileSync(tmp, JSON.stringify(l, null, 2));
-    fs6.renameSync(tmp, f);
+    fs8.writeFileSync(tmp, JSON.stringify(l, null, 2));
+    fs8.renameSync(tmp, f);
     return l;
   }
   /**
@@ -2820,13 +2991,13 @@ var LeaseStore = class {
    * breakIfStale), never by moving it aside, so the lock path is never left free while a live holder has it.
    */
   async withLock(fn) {
-    fs6.mkdirSync(this.dir, { recursive: true });
-    const lock = path10.join(this.dir, ".lock");
-    const token = `${this.pid}-${crypto.randomBytes(6).toString("hex")}`;
-    const tmp = path10.join(this.dir, `.lock.${token}.tmp`);
+    fs8.mkdirSync(this.dir, { recursive: true });
+    const lock = path12.join(this.dir, ".lock");
+    const token = `${this.pid}-${crypto2.randomBytes(6).toString("hex")}`;
+    const tmp = path12.join(this.dir, `.lock.${token}.tmp`);
     const writeToken = () => {
-      fs6.mkdirSync(this.dir, { recursive: true });
-      fs6.writeFileSync(
+      fs8.mkdirSync(this.dir, { recursive: true });
+      fs8.writeFileSync(
         tmp,
         JSON.stringify({ pid: this.pid, at: this.now(), token })
       );
@@ -2857,7 +3028,7 @@ var LeaseStore = class {
         await new Promise((r2) => setTimeout(r2, 50));
       }
     } finally {
-      fs6.rmSync(tmp, { force: true });
+      fs8.rmSync(tmp, { force: true });
     }
     LIVE_TOKENS.add(token);
     try {
@@ -2872,7 +3043,7 @@ var LeaseStore = class {
   }
   /** Whether a parsed lock is a leftover: from before this boot, this process's own but not held, or old with a dead holder. */
   heldStale(held) {
-    if (held.at < this.now() - os5.uptime() * 1e3) return true;
+    if (held.at < this.now() - os6.uptime() * 1e3) return true;
     if (held.pid === process.pid && !LIVE_TOKENS.has(held.token)) return true;
     return this.now() - held.at > LOCK_STALE_MS && !pidAlive(held.pid);
   }
@@ -2883,15 +3054,15 @@ var LeaseStore = class {
   sweepStrays() {
     let names;
     try {
-      names = fs6.readdirSync(this.dir);
+      names = fs8.readdirSync(this.dir);
     } catch {
       return;
     }
     for (const n of names) {
       if (!STRAY.test(n)) continue;
-      const f = path10.join(this.dir, n);
+      const f = path12.join(this.dir, n);
       if (this.mtimeAgeMs(f) > LOCK_STALE_MS)
-        fs6.rmSync(f, { recursive: true, force: true });
+        fs8.rmSync(f, { recursive: true, force: true });
     }
   }
   /**
@@ -2902,12 +3073,12 @@ var LeaseStore = class {
   tryLink(tmp, lock, rewrite) {
     for (let attempt = 0; ; attempt++) {
       try {
-        fs6.linkSync(tmp, lock);
+        fs8.linkSync(tmp, lock);
         return true;
       } catch (e) {
         const code = e.code;
         if (code === "EEXIST") return false;
-        if (code === "ENOENT" && attempt === 0 && !fs6.existsSync(tmp)) {
+        if (code === "ENOENT" && attempt === 0 && !fs8.existsSync(tmp)) {
           rewrite();
           continue;
         }
@@ -2919,7 +3090,7 @@ var LeaseStore = class {
   stillStale(lock, judged) {
     let raw;
     try {
-      raw = fs6.readFileSync(lock, "utf8");
+      raw = fs8.readFileSync(lock, "utf8");
     } catch (e) {
       if (e.code === "ENOENT") return false;
       throw e;
@@ -2932,7 +3103,7 @@ var LeaseStore = class {
    * or, with no readable holder, the directory's mtime is older than LOCK_STALE_MS.
    */
   guardStale(guard) {
-    const held = readHeld(path10.join(guard, "holder"));
+    const held = readHeld(path12.join(guard, "holder"));
     if (held)
       return this.now() - held.at > LOCK_STALE_MS && !pidAlive(held.pid);
     return this.mtimeAgeMs(guard) > LOCK_STALE_MS;
@@ -2950,7 +3121,7 @@ var LeaseStore = class {
   breakIfStale(lock, token, take) {
     let raw;
     try {
-      raw = fs6.readFileSync(lock, "utf8");
+      raw = fs8.readFileSync(lock, "utf8");
     } catch (e) {
       if (e.code === "ENOENT") return "retry";
       throw e;
@@ -2960,57 +3131,57 @@ var LeaseStore = class {
     if (!stale) return "wait";
     const guard = `${lock}.break`;
     try {
-      fs6.mkdirSync(guard);
+      fs8.mkdirSync(guard);
     } catch (e) {
       if (e.code !== "EEXIST") throw e;
       if (!this.guardStale(guard)) return "wait";
       const moved = `${guard}.${token}.stale`;
       try {
-        fs6.renameSync(guard, moved);
+        fs8.renameSync(guard, moved);
       } catch (err) {
         if (err.code === "ENOENT") return "retry";
         throw err;
       }
-      fs6.rmSync(moved, { recursive: true, force: true });
+      fs8.rmSync(moved, { recursive: true, force: true });
       return "retry";
     }
     try {
-      fs6.writeFileSync(
-        path10.join(guard, "holder"),
+      fs8.writeFileSync(
+        path12.join(guard, "holder"),
         JSON.stringify({ pid: this.pid, at: this.now(), token })
       );
       this.beforeUnlink?.();
       if (!this.stillStale(lock, held)) return "retry";
       try {
-        fs6.unlinkSync(lock);
+        fs8.unlinkSync(lock);
       } catch (e) {
         if (e.code !== "ENOENT") throw e;
       }
       return take() ? "taken" : "retry";
     } finally {
-      fs6.rmSync(guard, { recursive: true, force: true });
+      fs8.rmSync(guard, { recursive: true, force: true });
     }
   }
   /** Age of a lock file by its modification time on the file system's clock; 0 when it is gone. */
   mtimeAgeMs(lock) {
     try {
-      return Date.now() - fs6.statSync(lock).mtimeMs;
+      return Date.now() - fs8.statSync(lock).mtimeMs;
     } catch {
       return 0;
     }
   }
   /** Unlinks the lock only when it still carries this holder's token; a lock it does not own is never removed. */
   release(lock, token) {
-    if (readHeld(lock)?.token === token) fs6.rmSync(lock, { force: true });
+    if (readHeld(lock)?.token === token) fs8.rmSync(lock, { force: true });
   }
   /** Every readable lease, in sequence order; a half-written file is skipped. */
   list() {
-    if (!fs6.existsSync(this.dir)) return [];
-    return fs6.readdirSync(this.dir).filter((f) => f.endsWith(".json")).sort().flatMap((f) => {
+    if (!fs8.existsSync(this.dir)) return [];
+    return fs8.readdirSync(this.dir).filter((f) => f.endsWith(".json")).sort().flatMap((f) => {
       try {
         return [
           JSON.parse(
-            fs6.readFileSync(path10.join(this.dir, f), "utf8")
+            fs8.readFileSync(path12.join(this.dir, f), "utf8")
           )
         ];
       } catch {
@@ -3023,25 +3194,25 @@ var LeaseStore = class {
     return this.list().find((l) => l.id === id) ?? null;
   }
   nextSeq() {
-    const f = path10.join(this.dir, ".seq");
+    const f = path12.join(this.dir, ".seq");
     const onDisk = Math.max(
       0,
-      ...fs6.readdirSync(this.dir).filter((name2) => name2.endsWith(".json")).map((name2) => Number(name2.split("-")[0])).filter(Number.isFinite)
+      ...fs8.readdirSync(this.dir).filter((name2) => name2.endsWith(".json")).map((name2) => Number(name2.split("-")[0])).filter(Number.isFinite)
     );
-    const parsed = fs6.existsSync(f) ? Number(fs6.readFileSync(f, "utf8")) : 0;
+    const parsed = fs8.existsSync(f) ? Number(fs8.readFileSync(f, "utf8")) : 0;
     const n = Math.max(Number.isFinite(parsed) ? parsed : 0, onDisk);
     const tmp = `${f}.${this.pid}.tmp`;
-    fs6.writeFileSync(tmp, String(n + 1));
-    fs6.renameSync(tmp, f);
+    fs8.writeFileSync(tmp, String(n + 1));
+    fs8.renameSync(tmp, f);
     return n + 1;
   }
   /** A new lease, pending (queued) or running (admitted at once), with `child_pid` the process running its start; call it under the lock. */
   async create(input, state, opts = {}) {
-    fs6.mkdirSync(this.dir, { recursive: true });
+    fs8.mkdirSync(this.dir, { recursive: true });
     const at = this.stamp();
     const l = {
       ...input,
-      id: `l_${crypto.randomBytes(8).toString("base64url").replace(/[^a-z0-9]/gi, "").toLowerCase().padEnd(10, "0").slice(0, 10)}`,
+      id: `l_${crypto2.randomBytes(8).toString("base64url").replace(/[^a-z0-9]/gi, "").toLowerCase().padEnd(10, "0").slice(0, 10)}`,
       seq: this.nextSeq(),
       state,
       child_pid: opts.child_pid ?? null,
@@ -3119,7 +3290,7 @@ var LeaseStore = class {
     for (const l of this.list()) {
       if (!ENDED.has(l.state) || !l.ended_at) continue;
       if (this.now() - Date.parse(l.ended_at) > maxAgeMs) {
-        fs6.rmSync(this.file(l), { force: true });
+        fs8.rmSync(this.file(l), { force: true });
         n++;
       }
     }
@@ -3137,7 +3308,7 @@ var EXIT_POLL_MS = 250;
 function exitingAt(dir) {
   try {
     const v = JSON.parse(
-      fs7.readFileSync(path11.join(dir, WATCHER_NOTE), "utf8")
+      fs9.readFileSync(path13.join(dir, WATCHER_NOTE), "utf8")
     );
     const at = typeof v.exiting_at === "string" ? Date.parse(v.exiting_at) : Number.NaN;
     return Number.isFinite(at) ? at : null;
@@ -3146,9 +3317,10 @@ function exitingAt(dir) {
   }
 }
 function watcherEntry(env = process.env, argv = process.argv) {
-  if (env.MCPROC_CLI_ENTRY) return path11.resolve(env.MCPROC_CLI_ENTRY);
+  if (env.MCPROC_CLI_ENTRY) return path13.resolve(env.MCPROC_CLI_ENTRY);
   const own2 = argv[1] ?? "";
-  if (own2.endsWith("cli.js")) return path11.resolve(own2);
+  const real = own2 ? realOf(own2) : "";
+  if (real.endsWith("cli.js")) return real;
   throw new McprocError(
     "NOT_STARTED",
     `cannot launch the lease watcher: this mcproc runs from ${own2 || "an unknown entry"}, not from a built cli.js`,
@@ -3180,10 +3352,10 @@ async function lookAndLaunch(ctx, dir, leaving) {
   if (await watcherOnline(ctx) && (leaving === null || exitingAt(dir) !== leaving))
     return "online";
   const entry = watcherEntry();
-  const file = path11.join(dir, "watcher.ecosystem.json");
-  fs7.mkdirSync(dir, { recursive: true });
-  fs7.rmSync(path11.join(dir, WATCHER_NOTE), { force: true });
-  fs7.writeFileSync(
+  const file = path13.join(dir, "watcher.ecosystem.json");
+  fs9.mkdirSync(dir, { recursive: true });
+  fs9.rmSync(path13.join(dir, WATCHER_NOTE), { force: true });
+  fs9.writeFileSync(
     file,
     JSON.stringify(
       {
@@ -3219,7 +3391,7 @@ async function lookAndLaunch(ctx, dir, leaving) {
 // src/core/leases/view.ts
 async function leasesView(dir = stateDir(), ctx) {
   const store = new LeaseStore(dir);
-  if (fs8.existsSync(store.dir))
+  if (fs10.existsSync(store.dir))
     await store.withLock(() => store.prune()).catch(() => {
     });
   const leases = store.list().map((l) => ({ ...l, position: store.positionOf(l.id) }));
@@ -3274,17 +3446,12 @@ function cancelLease(id, dir = stateDir()) {
   });
 }
 
-// src/core/leases/watcher.ts
-import { spawn as spawn2 } from "child_process";
-import fs12 from "fs";
-import path16 from "path";
-
-// src/core/actions.ts
-import path14 from "path";
+// src/core/stacks/collect.ts
+import os8 from "os";
 
 // src/core/list.ts
-import fs9 from "fs";
-import path12 from "path";
+import fs11 from "fs";
+import path14 from "path";
 
 // src/core/metrics.ts
 function cpuPercent(pids, before, after, clkTck, intervalSec) {
@@ -3472,7 +3639,7 @@ function parseRead(stdout, id, offset, opts = {}) {
   }
   const skipped = offset !== null && offset >= 0 && size >= offset ? Math.max(0, start - offset) : 0;
   const nextOffset = Math.max(start, size - partial);
-  const short = buf.length < size - ctxStart;
+  const short2 = buf.length < size - ctxStart;
   const anchor = hex && HEX.test(hex) ? { at: size, hex } : null;
   return {
     size,
@@ -3481,17 +3648,17 @@ function parseRead(stdout, id, offset, opts = {}) {
     lines,
     contextOnly,
     nextOffset,
-    short,
+    short: short2,
     anchor,
-    nextAnchor: anchorAt(buf, nextOffset, { size, ctxStart, short, anchor })
+    nextAnchor: anchorAt(buf, nextOffset, { size, ctxStart, short: short2, anchor })
   };
 }
 function anchorAt(buf, at, read) {
-  const { size, ctxStart, short, anchor } = read;
+  const { size, ctxStart, short: short2, anchor } = read;
   if (at === size) return anchor;
   const n = Math.min(16, at);
   const end = buf.length - (size - at);
-  if (!anchor || short || n <= 0 || at - n < ctxStart || end - n < 0)
+  if (!anchor || short2 || n <= 0 || at - n < ctxStart || end - n < 0)
     return null;
   const tail = buf.subarray(end - n);
   if (tail.includes(REPLACEMENT)) return null;
@@ -3635,8 +3802,8 @@ var LogMarks = class {
     this.m.set(key, e);
   }
 };
-var sinceMark = (path22, r) => ({
-  path: path22,
+var sinceMark = (path23, r) => ({
+  path: path23,
   offset: r.nextOffset,
   ...r.nextAnchor ? { at: r.nextAnchor.at, anchor: r.nextAnchor.hex } : {}
 });
@@ -3667,15 +3834,15 @@ async function readSince(fleet, names, opts) {
         );
         const files = targets.flatMap(
           (t) => streams2.map((stream2) => {
-            const path22 = stream2 === "out" ? t.p.out_log : t.p.err_log;
+            const path23 = stream2 === "out" ? t.p.out_log : t.p.err_log;
             const key = LogMarks.key(fleet.manifest.path, g.host, t.app);
             const mark = spec.kind === "last" ? opts.marks?.get(key)?.[stream2] : void 0;
-            const same = mark !== void 0 && mark.path === path22;
+            const same = mark !== void 0 && mark.path === path23;
             const anchor = same && mark.at !== void 0 && mark.anchor !== void 0 ? { at: mark.at, hex: mark.anchor } : null;
             return {
               app: t.app,
               stream: stream2,
-              path: path22,
+              path: path23,
               key,
               offset: same ? mark.offset : null,
               anchor,
@@ -4108,38 +4275,14 @@ function urlFields(u) {
     url_reason: null
   };
 }
-async function snapshot(ctx, opts = {}) {
-  const withMetrics = opts.metrics !== "none";
-  const cpuSample = (opts.cpu ?? "inline") === "inline" && withMetrics;
-  const which = opts.urls ?? "check";
-  const asked = which === "none" ? [] : Object.values(ctx.manifest.apps).flatMap(
-    (a) => a.url !== null && (which === "check" || which.includes(a.name)) ? [{ name: a.name, url: a.url, url_check: a.url_check }] : []
-  );
-  const urls = [
-    ...new Set(
-      asked.filter((a) => ctx.host.local || a.url_check !== "here").map((a) => a.url)
-    )
-  ];
-  const containers = withMetrics && opts.containers === "probe" ? [
-    ...new Set(
-      Object.values(ctx.manifest.apps).flatMap((a) => a.containers)
-    )
-  ] : [];
+async function probeHost(link, ask) {
   const res = ensureOk(
-    await ctx.transport.exec(
-      probeScript(ctx.pm2.bin, {
-        cpuSample,
-        urls,
-        metrics: withMetrics,
-        containers
-      }),
-      {
-        env: ctx.pm2.env(),
-        // each url adds its bounded lookup and request: many on a host whose resolver drops packets outlast the default
-        timeoutMs: probeTimeoutMs(urls.length)
-      }
-    ),
-    ctx.host,
+    await link.transport.exec(probeScript(link.pm2.bin, ask), {
+      env: link.pm2.env(),
+      // each url adds its bounded lookup and request: many on a host whose resolver drops packets outlast the default
+      timeoutMs: probeTimeoutMs(ask.urls.length)
+    }),
+    link.host,
     "probe"
   );
   const sampledAt = Date.now();
@@ -4147,9 +4290,9 @@ async function snapshot(ctx, opts = {}) {
     const tail = (res.stderr || res.stdout).trim().split("\n").slice(-5).join("\n");
     throw new McprocError(
       "TRANSPORT_FAILED",
-      `the shell on ${ctx.transport.describe()} did not run the probe (exit ${res.code}): ${tail}`,
+      `the shell on ${link.transport.describe()} did not run the probe (exit ${res.code}): ${tail}`,
       {
-        hint: `Check hosts.${ctx.host.name}.shell (default /bin/bash -lc) exists on that host.`
+        hint: `Check hosts.${link.host.name}.shell (default /bin/bash -lc) exists on that host.`
       }
     );
   }
@@ -4157,27 +4300,37 @@ async function snapshot(ctx, opts = {}) {
   if (data.jlistRc === 127)
     throw new McprocError(
       "PM2_NOT_FOUND",
-      `pm2 not found on ${ctx.transport.describe()}`,
+      `pm2 not found on ${link.transport.describe()}`,
       { hint: PM2_NOT_FOUND_HINT }
     );
   if (data.jlistRc !== 0)
     throw new McprocError(
       "PM2_FAILED",
-      `pm2 jlist exited ${data.jlistRc} on ${ctx.transport.describe()}`,
+      `pm2 jlist exited ${data.jlistRc} on ${link.transport.describe()}`,
       { details: res.stderr.slice(-500) }
     );
-  const procs = parseJlist(data.jlistRaw);
+  return { data, procs: parseJlist(data.jlistRaw), sampledAt };
+}
+function askedUrls(view, opts) {
+  const which = opts.urls ?? "check";
+  return which === "none" ? [] : Object.values(view.manifest.apps).flatMap(
+    (a) => a.url !== null && (which === "check" || which.includes(a.name)) ? [{ name: a.name, url: a.url, url_check: a.url_check }] : []
+  );
+}
+async function deriveSnapshot(view, probe, opts = {}) {
+  const { data, procs, sampledAt } = probe;
+  const asked = askedUrls(view, opts);
   const pids = appPids(
-    ctx.manifest.apps,
+    view.manifest.apps,
     procs,
     data.tree,
-    ctx.manifest.project
+    view.manifest.project
   );
   const metricOpts = opts.prev ? { prev: opts.prev.sample, intervalSec: (sampledAt - opts.prev.at) / 1e3 } : {};
   const metrics = {};
   for (const [name2, set] of pids)
     metrics[name2] = treeMetrics(set, data.stats, data.listeners, metricOpts);
-  for (const app of Object.values(ctx.manifest.apps)) {
+  for (const app of Object.values(view.manifest.apps)) {
     const m = metrics[app.name];
     if (!m || app.containers.length === 0) continue;
     const mib = app.containers.reduce(
@@ -4193,13 +4346,13 @@ async function snapshot(ctx, opts = {}) {
   }
   const urlChecks = await settleUrls(
     asked,
-    { host: ctx.host.name, local: ctx.host.local },
+    { host: view.host.name, local: view.host.local },
     data,
-    ctx.hereCheck
+    view.hereCheck
   );
   return {
     procs,
-    ports: joinPorts(ctx.manifest.apps, procs, data, ctx.manifest.project),
+    ports: joinPorts(view.manifest.apps, procs, data, view.manifest.project),
     listeners: data.listeners,
     tree: data.tree,
     stats: data.stats,
@@ -4208,9 +4361,30 @@ async function snapshot(ctx, opts = {}) {
     urlChecks,
     zone: data.zone,
     memory: data.memory,
-    leases: ctx.host.local && opts.leases !== "none" ? leasesCovering(stateDir(), ctx.manifest) : []
+    leases: view.host.local && opts.leases !== "none" ? leasesCovering(stateDir(), view.manifest) : []
   };
 }
+async function snapshot(ctx, opts = {}) {
+  const withMetrics = opts.metrics !== "none";
+  const asked = askedUrls(ctx, opts);
+  const urls = [
+    ...new Set(
+      asked.filter((a) => ctx.host.local || a.url_check !== "here").map((a) => a.url)
+    )
+  ];
+  const containers = withMetrics && opts.containers === "probe" ? [
+    ...new Set(
+      Object.values(ctx.manifest.apps).flatMap((a) => a.containers)
+    )
+  ] : [];
+  const probe = await probeHost(ctx, {
+    cpuSample: (opts.cpu ?? "inline") === "inline" && withMetrics,
+    metrics: withMetrics,
+    urls,
+    containers
+  });
+  return deriveSnapshot(ctx, probe, opts);
+}
 var SIGNAL_EXITS = /* @__PURE__ */ new Set([130, 143]);
 function statusWord(p, app) {
   if (!p) return "not-started";
@@ -4345,8 +4519,8 @@ var depView = (d) => ({
   timeout_s: d.timeoutMs / 1e3
 });
 function describeProject(m) {
-  const readmePath = path12.join(m.root, ".mcproc", "README.md");
-  const readme = fs9.existsSync(readmePath) ? fs9.readFileSync(readmePath, "utf8") : null;
+  const readmePath = path14.join(m.root, ".mcproc", "README.md");
+  const readme = fs11.existsSync(readmePath) ? fs11.readFileSync(readmePath, "utf8") : null;
   return {
     project: m.project,
     root: m.root,
@@ -4377,9 +4551,12 @@ function describeProject(m) {
   };
 }
 
+// src/core/actions.ts
+import path16 from "path";
+
 // src/core/logfollow.ts
 import { open } from "fs/promises";
-import path13 from "path";
+import path15 from "path";
 
 // src/core/logwatch.ts
 import { watch as fsWatch } from "fs";
@@ -4722,8 +4899,8 @@ function hostStreamFor(t) {
 var MAX_PENDING = 65536;
 var MAX_READY = 1e4;
 function chunkScript(reqs) {
-  return reqs.map(({ path: path22, off, anchor }, i) => {
-    const f = shq(path22);
+  return reqs.map(({ path: path23, off, anchor }, i) => {
+    const f = shq(path23);
     const tail = `st=$((sz>${HISTORY_BYTES}?sz-${HISTORY_BYTES}:0))`;
     const replaced = off !== null && anchor ? ` || [ "${hex16(f, String(off))}" != '${anchor}' ]` : "";
     const pick = off === null ? `k=H; ${tail}` : `if [ "$sz" -lt ${off} ]${replaced}; then k=R; ${tail}; elif [ $((sz-${off})) -gt ${READ_CAP2} ]; then k=S; st=$((sz-${READ_CAP2})); else k=N; st=${off}; fi`;
@@ -4873,8 +5050,8 @@ var LogFollower = class {
     }
     const byDir = /* @__PURE__ */ new Map();
     for (const p of [this.paths.out, this.paths.err]) {
-      const dir = path13.dirname(p);
-      byDir.set(dir, (byDir.get(dir) ?? /* @__PURE__ */ new Set()).add(path13.basename(p)));
+      const dir = path15.dirname(p);
+      byDir.set(dir, (byDir.get(dir) ?? /* @__PURE__ */ new Set()).add(path15.basename(p)));
     }
     for (const [dir, names] of byDir)
       this.unwatch.push(
@@ -5247,6 +5424,9 @@ function detectReloads(input, rules, opts) {
   return [...t.push(input, 0), ...t.flush()];
 }
 
+// src/mcp/render.ts
+import os7 from "os";
+
 // src/core/logstream.ts
 var WAKE_GAP_MS = 50;
 function signals() {
@@ -5442,42 +5622,242 @@ async function streamLogs(sources, opts, deps2) {
   }
 }
 
-// src/mcp/render.ts
-function fmtUptime(ms) {
-  if (ms === null) return "-";
-  const s = Math.floor(ms / 1e3);
-  if (s < 60) return `${s}s`;
-  const m = Math.floor(s / 60);
-  if (m < 60) return `${m}m`;
-  const h = Math.floor(m / 60);
-  if (h < 48) return `${h}h${m % 60}m`;
-  return `${Math.floor(h / 24)}d`;
-}
-function fmtBytes(b) {
-  if (b < 1024) return `${b}B`;
-  if (b < 1024 ** 2) return `${(b / 1024).toFixed(0)}K`;
-  if (b < 1024 ** 3) return `${(b / 1024 ** 2).toFixed(1)}M`;
-  return `${(b / 1024 ** 3).toFixed(2)}G`;
-}
-function fmtPorts(p) {
-  const parts = [];
-  for (const c of p.checks) {
-    if (c.status === "listening") parts.push(`:${c.port} \u2713`);
-    else if (c.held_by) {
-      const who = c.held_by.app ? `app ${c.held_by.app}` : c.held_by.container ? `container ${c.held_by.container}` : c.held_by.pid !== null ? `pid ${c.held_by.pid}${c.held_by.command ? ` (${c.held_by.command})` : ""}` : "another user's process";
-      parts.push(`:${c.port} \u2717 held by ${who}`);
-    } else parts.push(`:${c.port} \u2717 nothing listens`);
-  }
+// src/monit/screentext.ts
+import { charWidth, chars } from "@pm2/blessed/lib/unicode.js";
+var segmenter = new Intl.Segmenter("en", { granularity: "grapheme" });
+var EMOJI_PRESENTATION = new RegExp("\\p{Emoji_Presentation}", "u");
+var PICTOGRAPH = new RegExp("\\p{Extended_Pictographic}", "u");
+var REGIONAL = new RegExp("\\p{Regional_Indicator}", "u");
+var KEYCAP = /^[0-9#*]\uFE0F?\u20E3$/;
+var INVISIBLE = /[\p{Cc}\p{Cf}]/u;
+var LINE_BREAK = /\r\n|[\n\v\f\u0085\u2028\u2029]/g;
+var MARK2 = new RegExp("\\p{M}", "u");
+var SPACING_MARK = new RegExp("\\p{Mc}", "u");
+var BLESSED_WIDE = new RegExp(chars.wide.source);
+var NARROW = {
+  "\u2705": "\u2714",
+  "\u274C": "\u2716",
+  "\u274E": "\u2716",
+  "\u2757": "!",
+  "\u2755": "!",
+  "\u2753": "?",
+  "\u2754": "?"
+};
+var TAB = 8;
+function displayWidth(s) {
+  let w = 0;
+  for (const ch of s.includes("\x1B") ? s.replace(SGR_RE, "") : s)
+    w += charWidth(ch.codePointAt(0)) === 2 ? 2 : 1;
+  return w;
+}
+function columns(s) {
+  let w = 0;
+  for (const ch of s) w += charWidth(ch.codePointAt(0));
+  return w;
+}
+function keepMark(ch, cp) {
+  return cp <= 65535 && charWidth(cp) === (SPACING_MARK.test(ch) ? 1 : 0);
+}
+function cluster(c) {
+  if (c === "	") return c;
+  const first = String.fromCodePoint(c.codePointAt(0));
+  if (REGIONAL.test(first))
+    return [...c].filter((ch) => REGIONAL.test(ch)).map((ch) => String.fromCharCode(ch.codePointAt(0) - 127462 + 65)).join("");
+  if (KEYCAP.test(c)) return c[0];
+  if (PICTOGRAPH.test(first) || EMOJI_PRESENTATION.test(first)) {
+    if (NARROW[first]) return NARROW[first];
+    return !EMOJI_PRESENTATION.test(first) && first.length === 1 ? first : "?";
+  }
+  let out = "";
+  for (const ch of c) {
+    if (INVISIBLE.test(ch)) continue;
+    const cp = ch.codePointAt(0);
+    if (MARK2.test(ch)) {
+      if (keepMark(ch, cp)) out += ch;
+      continue;
+    }
+    if (cp > 65535 || cp >= 55296 && cp <= 57343) {
+      out += "?";
+      continue;
+    }
+    out += charWidth(cp) === 2 === BLESSED_WIDE.test(ch) ? ch : "?";
+  }
+  return out;
+}
+function blessedSgr(code) {
+  if (!code.includes(":")) return code;
+  const groups = code.slice(2, -1).split(";").flatMap((g) => {
+    if (!g.includes(":")) return [g];
+    const [kind, mode, ...rest] = g.split(":");
+    if (kind === "4") return ["4"];
+    if (!["38", "48", "58"].includes(kind)) return [];
+    if (mode === "5" && rest[0]) return [`${kind};5;${rest[0]}`];
+    if (mode === "2" && rest.length >= 3)
+      return [`${kind};2;${rest.slice(-3).join(";")}`];
+    return [];
+  });
+  return groups.length ? `\x1B[${groups.join(";")}m` : "";
+}
+var SGR_SPLIT = /(\x1b\[[0-9;:]*m)/;
+var visible = (t) => t.replace(SGR_RE, "");
+function screenText(input, opts = {}) {
+  const parts = (opts.colors ? keepSgr(input) : stripAnsi(input)).replace(/\r\n/g, "\n").split("\r");
+  let last = parts.length - 1;
+  while (last > 0 && visible(parts[last]) === "") last--;
+  const carried = parts.slice(0, last).flatMap((p) => p.match(SGR_RE) ?? []).join("");
+  let out = "";
+  let col = 0;
+  for (const piece of (carried + parts[last]).split(SGR_SPLIT)) {
+    if (SGR_SPLIT.test(piece) && piece.startsWith("\x1B")) {
+      out += blessedSgr(piece);
+      continue;
+    }
+    for (const { segment } of segmenter.segment(
+      piece.replace(LINE_BREAK, " ").normalize("NFC")
+    )) {
+      const c = cluster(segment);
+      if (c === "	") {
+        const n = TAB - col % TAB;
+        out += " ".repeat(n);
+        col += n;
+        continue;
+      }
+      out += c;
+      col += columns(c);
+    }
+  }
+  return out;
+}
+function cutWidth(s, width) {
+  if (displayWidth(s) <= width) return s;
+  let out = "";
+  let w = 0;
+  for (const ch of s) {
+    const cw = displayWidth(ch);
+    if (w + cw > width - 1) break;
+    out += ch;
+    w += cw;
+  }
+  return `${out}\u2026`;
+}
+function cutStartWidth(s, width) {
+  if (displayWidth(s) <= width) return s;
+  const all = [...s];
+  let out = "";
+  for (let i = all.length - 1; i >= 0; i--) {
+    if (displayWidth(all[i] + out) > width - 1) break;
+    out = all[i] + out;
+  }
+  return `\u2026${out}`;
+}
+
+// src/mcp/render.ts
+function fmtUptime(ms) {
+  if (ms === null) return "-";
+  const s = Math.floor(ms / 1e3);
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m`;
+  const h = Math.floor(m / 60);
+  if (h < 48) return `${h}h${m % 60}m`;
+  return `${Math.floor(h / 24)}d`;
+}
+function fmtBytes(b) {
+  if (b < 1024) return `${b}B`;
+  if (b < 1024 ** 2) return `${(b / 1024).toFixed(0)}K`;
+  if (b < 1024 ** 3) return `${(b / 1024 ** 2).toFixed(1)}M`;
+  return `${(b / 1024 ** 3).toFixed(2)}G`;
+}
+function fmtPorts(p) {
+  const parts = [];
+  for (const c of p.checks) {
+    if (c.status === "listening") parts.push(`:${c.port} \u2713`);
+    else if (c.held_by) {
+      const who = c.held_by.app ? `app ${c.held_by.app}` : c.held_by.container ? `container ${c.held_by.container}` : c.held_by.pid !== null ? `pid ${c.held_by.pid}${c.held_by.command ? ` (${c.held_by.command})` : ""}` : "another user's process";
+      parts.push(`:${c.port} \u2717 held by ${who}`);
+    } else parts.push(`:${c.port} \u2717 nothing listens`);
+  }
   for (const u of p.undeclared) parts.push(`:${u} (undeclared)`);
   return parts.length ? parts.join(", ") : "-";
 }
-function table(rows) {
-  const w = rows[0].map(
-    (_, i) => Math.max(...rows.map((r) => (r[i] ?? "").length))
+var GUTTER = 2;
+var FLEX_MIN = 12;
+function fitWidths(natural, flex, width) {
+  const w = [...natural];
+  const floor = (i) => Math.min(FLEX_MIN, natural[i]);
+  let total = w.reduce((a, b) => a + b, 0) + GUTTER * (w.length - 1);
+  while (total > width) {
+    let pick = -1;
+    for (const i of flex)
+      if (w[i] > floor(i) && (pick < 0 || w[i] > w[pick])) pick = i;
+    if (pick < 0) break;
+    w[pick]--;
+    total--;
+  }
+  return w;
+}
+function takeWidth(s, width) {
+  let out = "";
+  for (const ch of s) {
+    if (out && displayWidth(out + ch) > width) break;
+    out += ch;
+  }
+  return out;
+}
+function wrapCell(s, width) {
+  if (displayWidth(s) <= width) return [s];
+  const lines = [];
+  let line = "";
+  for (let t of s.match(/[^\s/,:-]*[\s/,:-]*/g)?.filter(Boolean) ?? []) {
+    if (displayWidth((line + t).trimEnd()) <= width) {
+      line += t;
+      continue;
+    }
+    if (line.trim()) lines.push(line.trimEnd());
+    line = "";
+    while (displayWidth(t.trimEnd()) > width) {
+      const head = takeWidth(t, width);
+      lines.push(head);
+      t = t.slice(head.length);
+    }
+    line = t;
+  }
+  if (line.trim()) lines.push(line.trimEnd());
+  return lines;
+}
+function table(rows, opts = {}) {
+  if (opts.width === void 0) {
+    const w = rows[0].map(
+      (_, i) => Math.max(...rows.map((r) => (r[i] ?? "").length))
+    );
+    return rows.map(
+      (r) => r.map((c, i) => (c ?? "").padEnd(w[i])).join("  ").trimEnd()
+    ).join("\n");
+  }
+  const at = (r, i) => r[i] ?? "";
+  const natural = rows[0].map(
+    (_, i) => Math.max(...rows.map((r) => displayWidth(at(r, i))))
   );
-  return rows.map(
-    (r) => r.map((c, i) => (c ?? "").padEnd(w[i])).join("  ").trimEnd()
-  ).join("\n");
+  const widths = fitWidths(natural, opts.flex ?? [], opts.width);
+  const flex = new Set(opts.flex ?? []);
+  const starts = new Set(opts.cutStart ?? []);
+  const pad2 = (s, w) => s + " ".repeat(Math.max(0, w - displayWidth(s)));
+  const out = [];
+  for (const r of rows) {
+    const cells = widths.map((w, i) => {
+      const s = at(r, i);
+      if (!flex.has(i) || displayWidth(s) <= w) return [s];
+      if (opts.mode === "fit")
+        return [starts.has(i) ? cutStartWidth(s, w) : cutWidth(s, w)];
+      return wrapCell(s, w);
+    });
+    const height = Math.max(...cells.map((c) => c.length));
+    for (let k = 0; k < height; k++)
+      out.push(
+        cells.map((c, i) => pad2(c[k] ?? "", widths[i])).join(" ".repeat(GUTTER)).trimEnd()
+      );
+  }
+  return out.join("\n");
 }
 function fmtCpu(c) {
   return c === null ? "-" : `${c.toFixed(1)}%`;
@@ -5505,7 +5885,7 @@ function fmtRestarts(r) {
   const n = r.reloads;
   return n && n.count > 0 ? `${r.restarts} (+${n.partial ? "\u2265" : ""}${n.count})` : String(r.restarts);
 }
-function renderLs(rows, host, errors = []) {
+function renderLs(rows, host, errors = [], width) {
   const hosts = [...new Set(rows.map((r) => r.host))];
   const multi = hosts.length > 1;
   const head = multi ? `hosts: ${hosts.join(", ")}` : `host: ${hosts[0] ?? host}`;
@@ -5514,40 +5894,45 @@ function renderLs(rows, host, errors = []) {
       rows.filter((r) => r.error).map((r) => [r.host, `${r.host}: ${r.error}`])
     ).values()
   ];
+  const o = multi ? 1 : 0;
+  const cap = (s, n) => width === void 0 ? cut2(s, n) : s;
   return [
     head,
-    table([
+    table(
       [
-        "APP",
-        ...multi ? ["HOST"] : [],
-        "KIND",
-        "STATUS",
-        "PID",
-        "UPTIME",
-        "RESTARTS",
-        "MEM",
-        "CPU",
-        "PORTS",
-        "URL",
-        "RUNTIME",
-        "DESCRIPTION"
+        [
+          "APP",
+          ...multi ? ["HOST"] : [],
+          "KIND",
+          "STATUS",
+          "PID",
+          "UPTIME",
+          "RESTARTS",
+          "MEM",
+          "CPU",
+          "PORTS",
+          "URL",
+          "RUNTIME",
+          "DESCRIPTION"
+        ],
+        ...rows.map((r) => [
+          r.app,
+          ...multi ? [r.host] : [],
+          r.kind,
+          r.status,
+          r.pid === null ? "-" : String(r.pid),
+          fmtUptime(r.uptime_ms),
+          fmtRestarts(r),
+          r.memory ? fmtBytes(r.memory) : "-",
+          r.status === "online" ? fmtCpu(r.cpu) : "-",
+          fmtPorts(r.ports),
+          fmtUrl(r),
+          r.runtime ? cap(r.runtime, 32) : "-",
+          cap(r.description.split("\n")[0], 40)
+        ])
       ],
-      ...rows.map((r) => [
-        r.app,
-        ...multi ? [r.host] : [],
-        r.kind,
-        r.status,
-        r.pid === null ? "-" : String(r.pid),
-        fmtUptime(r.uptime_ms),
-        fmtRestarts(r),
-        r.memory ? fmtBytes(r.memory) : "-",
-        r.status === "online" ? fmtCpu(r.cpu) : "-",
-        fmtPorts(r.ports),
-        fmtUrl(r),
-        r.runtime ? cut2(r.runtime, 32) : "-",
-        cut2(r.description.split("\n")[0], 40)
-      ])
-    ]),
+      { width, flex: [8 + o, 9 + o, 10 + o, 11 + o], mode: "wrap" }
+    ),
     ...unreachable,
     ...errors.map((e) => `${e.host}: ${e.message}`)
   ].join("\n");
@@ -5564,36 +5949,42 @@ function startNote(rows) {
   );
   return booting.length ? `note: ${booting.map((r) => r.app).join(", ")} not listening yet; ports are sampled right after start, call wait until listening instead of polling ls` : "";
 }
-function renderPorts(rep, host) {
+function renderPorts(rep, host, width) {
   if (rep.listeners.length === 0)
     return `host: ${host}
 ${rep.port ? `nothing listens on port ${rep.port}` : "no listening sockets visible"}`;
   return `host: ${host}
-` + table([
-    ["PROTO", "ADDR", "PORT", "PID", "COMMAND", "APP", "CONTAINER"],
-    ...rep.listeners.map((l) => [
-      l.proto,
-      l.addr,
-      String(l.port),
-      l.pid === null ? "?" : String(l.pid),
-      l.command ?? "?",
-      l.app ?? "-",
-      l.container ?? "-"
-    ])
-  ]);
+` + table(
+    [
+      ["PROTO", "ADDR", "PORT", "PID", "COMMAND", "APP", "CONTAINER"],
+      ...rep.listeners.map((l) => [
+        l.proto,
+        l.addr,
+        String(l.port),
+        l.pid === null ? "?" : String(l.pid),
+        l.command ?? "?",
+        l.app ?? "-",
+        l.container ?? "-"
+      ])
+    ],
+    { width, flex: [4], mode: "wrap" }
+  );
 }
-function renderHosts(info) {
-  return table([
-    ["HOST", "TRANSPORT", "CWD", "READONLY", "PM2_HOME", "APPS"],
-    ...info.map((h) => [
-      h.name,
-      h.transport,
-      h.cwd,
-      h.readonly ? "yes" : "no",
-      h.pm2_home ?? "-",
-      h.apps.length ? h.apps.join(", ") : "-"
-    ])
-  ]);
+function renderHosts(info, width) {
+  return table(
+    [
+      ["HOST", "TRANSPORT", "CWD", "READONLY", "PM2_HOME", "APPS"],
+      ...info.map((h) => [
+        h.name,
+        h.transport,
+        h.cwd,
+        h.readonly ? "yes" : "no",
+        h.pm2_home ?? "-",
+        h.apps.length ? h.apps.join(", ") : "-"
+      ])
+    ],
+    { width, flex: [1, 2, 4, 5], mode: "wrap" }
+  );
 }
 function fmtEnv(e) {
   const kind = e.container === "none" ? "no container" : `container (${e.container})`;
@@ -5741,7 +6132,7 @@ function fmtDeps(deps2) {
     (d) => d.condition === "started" ? d.app : `${d.app} (${d.condition})`
   ).join(", ");
 }
-function renderProject(d) {
+function renderProject(d, width) {
   const L = [`project: ${d.project} (${d.root})`];
   const w = d.mcproc.manifest;
   if (w)
@@ -5765,7 +6156,7 @@ function renderProject(d) {
     L.push(`  ${p}: ${apps.join(", ")}`);
   L.push(
     "hosts:",
-    renderHosts(d.hosts).split("\n").map((x) => `  ${x}`).join("\n")
+    renderHosts(d.hosts, width === void 0 ? void 0 : width - 2).split("\n").map((x) => `  ${x}`).join("\n")
   );
   if (d.readme) L.push("", "README:", d.readme.trim());
   return L.join("\n");
@@ -5788,9 +6179,9 @@ function incidentLines(i, opts = {}) {
 function renderIncidents(a, opts = {}) {
   const tail = [];
   if (a.more > 0) {
-    const short = a.more_by === "size" ? " to keep this answer short" : "";
+    const short2 = a.more_by === "size" ? " to keep this answer short" : "";
     tail.push(
-      a.taken ? `+${a.more} older incidents not shown${short}, taken with these (read logs for them)` : short ? `+${a.more} more incidents not shown${short} (pass app for one app, or read logs)` : `+${a.more} more incidents (raise max)`
+      a.taken ? `+${a.more} older incidents not shown${short2}, taken with these (read logs for them)` : short2 ? `+${a.more} more incidents not shown${short2} (pass app for one app, or read logs)` : `+${a.more} more incidents (raise max)`
     );
   }
   for (const s of a.skipped)
@@ -5839,7 +6230,7 @@ function queuedNote(rows) {
     return l.state === "starting" ? `${apps}: starting (lease ${l.id})` : `${apps}: queued #${l.position}${l.waiting_for ? `: ${l.waiting_for}` : ""} (lease ${l.id}; wait on an app, or leases)`;
   }).join("\n");
 }
-function renderLeases(v) {
+function renderLeases(v, width) {
   const head = [
     `state: ${v.state_dir}`,
     v.memory ? `memory: ${fmtMib(v.memory.available_mib)} available of ${fmtMib(v.memory.total_mib)}` : "memory: no reading on this host (leases are admitted in FIFO order without a check)",
@@ -5859,23 +6250,26 @@ function renderLeases(v) {
   ]);
   return [
     ...head,
-    table([
+    table(
       [
-        "POS",
-        "STATE",
-        "KIND",
-        "PROJECT",
-        "TARGET",
-        "EST \u2192 NEED",
-        "FROM",
-        "WAITING FOR / ERROR",
-        "ID"
+        [
+          "POS",
+          "STATE",
+          "KIND",
+          "PROJECT",
+          "TARGET",
+          "EST \u2192 NEED",
+          "FROM",
+          "WAITING FOR / ERROR",
+          "ID"
+        ],
+        ...rows
       ],
-      ...rows
-    ])
+      { width, flex: [4, 7], mode: "wrap" }
+    )
   ].join("\n");
 }
-function renderMutation(rows, fallback, act, waits = []) {
+function renderMutation(rows, fallback, act, waits = [], width) {
   const bad3 = rows.filter((r) => r.error);
   const notes = [
     act === "start" || act === "restart" ? startNote(rows) : "",
@@ -5886,7 +6280,7 @@ function renderMutation(rows, fallback, act, waits = []) {
   const head = bad3.length ? `${act} partly failed: ${bad3.map((r) => `${r.app} (${r.host}): ${r.error}`).join("; ")}
 ` : "";
   return {
-    text: head + renderLs(rows, fallback) + notes.map((n) => `
+    text: head + renderLs(rows, fallback, [], width) + notes.map((n) => `
 ${n}`).join(""),
     failed: bad3.length > 0
   };
@@ -5940,22 +6334,123 @@ function renderWorktreeAdded(r) {
   L.push(`next: ${r.next}`);
   return L.join("\n");
 }
-function renderWorktrees(rows) {
-  return table([
-    ["SLOT", "PROJECT", "BRANCH", "ONLINE", "LEASE", "PATH"],
-    ...rows.map((r) => [
-      r.main ? `${r.slot} (main)` : String(r.slot),
-      r.project,
-      r.branch ?? "(detached)",
-      String(r.online),
-      r.lease ?? "-",
-      r.path
-    ])
-  ]);
+function renderWorktrees(rows, width) {
+  return table(
+    [
+      ["SLOT", "PROJECT", "BRANCH", "ONLINE", "LEASE", "PATH"],
+      ...rows.map((r) => [
+        r.main ? `${r.slot} (main)` : String(r.slot),
+        r.project,
+        r.branch ?? "(detached)",
+        String(r.online),
+        r.lease ?? "-",
+        r.path
+      ])
+    ],
+    { width, flex: [2, 5], mode: "wrap" }
+  );
 }
 function renderWorktreeRemoved(r) {
   return `removed ${r.path}: slot ${r.slot} is free, branch ${r.branch ?? "(detached)"} kept; stopped ${r.stopped.length ? r.stopped.join(", ") : "nothing"}`;
 }
+function tildePath(p, home = os7.homedir()) {
+  return p === home || p.startsWith(`${home}/`) ? `~${p.slice(home.length)}` : p;
+}
+function stackLabel(s, nested) {
+  if (s.base_project === s.project) return s.project;
+  const wt = `${s.slot !== null ? `w${s.slot} ` : ""}${s.branch ?? s.project}`;
+  return nested ? `  ${wt}` : `${s.base_project} ${wt}`;
+}
+function stackApps(s) {
+  if (s.queue_position !== null && s.apps.online === 0)
+    return `queued #${s.queue_position}`;
+  return s.present ? `${s.apps.online}/${s.apps.total}` : "not running";
+}
+function stackPorts(s, max = 3) {
+  const ports = [...new Set(s.ports.map((p) => p.port))].sort((a, b) => a - b);
+  if (ports.length === 0) return "-";
+  const shown = ports.slice(0, max).map((p) => `:${p}`).join(" ");
+  return ports.length > max ? `${shown} +${ports.length - max}` : shown;
+}
+var stackCells = (s, nested, root) => [
+  stackLabel(s, nested),
+  root(s.root),
+  s.hosts.map((h) => h.name).join(","),
+  s.manifest_error ? "manifest error" : stackApps(s),
+  String(s.apps.errored),
+  s.memory ? fmtBytes(s.memory) : "-",
+  s.cpu === null ? "-" : `${Math.round(s.cpu)}%`,
+  stackPorts(s)
+];
+var orphanCells = (o) => {
+  const mem = o.processes.reduce((a, p) => a + p.memory, 0);
+  return [
+    `pm2 \xB7 ${o.namespace}`,
+    "(no manifest)",
+    o.endpoint,
+    `${o.processes.filter((p) => p.status === "online").length}/${o.processes.length}`,
+    "-",
+    mem ? fmtBytes(mem) : "-",
+    "-",
+    "-"
+  ];
+};
+var STACK_HEADER = [
+  "STACK",
+  "ROOT",
+  "HOSTS",
+  "APPS",
+  "ERR",
+  "MEM",
+  "CPU",
+  "PORTS"
+];
+function stacksHostLine(h) {
+  const mem = h.memory ? `RAM ${fmtMib(h.memory.available_mib)} free of ${fmtMib(h.memory.total_mib)}` : "no memory reading";
+  const watcher = h.watcher ? h.watcher.online ? "watcher online" : "watcher stopped" : "no watcher";
+  return `${h.name} \xB7 ${mem} \xB7 ${watcher} \xB7 queue ${h.queue}`;
+}
+function renderStacks(a, width, home = os7.homedir()) {
+  const lines = [`host: ${stacksHostLine(a.host)}`, ...a.host.notes];
+  if (a.stacks.length === 0 && a.orphans.length === 0)
+    return [
+      ...lines,
+      "no stacks running on this host (--all lists the recorded ones)"
+    ].join("\n");
+  const bases = new Set(a.stacks.map((s) => s.project));
+  const root = (p) => width === void 0 ? p : tildePath(p, home);
+  lines.push(
+    table(
+      [
+        STACK_HEADER,
+        ...a.stacks.map(
+          (s) => stackCells(
+            s,
+            s.base_project !== s.project && bases.has(s.base_project),
+            root
+          )
+        ),
+        ...a.orphans.map(orphanCells)
+      ],
+      { width, flex: [1, 7], mode: "wrap" }
+    )
+  );
+  for (const s of a.stacks) {
+    if (s.manifest_error)
+      lines.push(
+        `${s.project}: ${s.manifest_error.code}: ${s.manifest_error.message}${s.manifest_error.hint ? ` (${s.manifest_error.hint})` : ""}`
+      );
+    for (const n of s.notes) lines.push(`${s.project}: ${n}`);
+    for (const h of s.hosts)
+      if (h.error)
+        lines.push(
+          `${s.project} on ${h.name}: ${h.error}${h.age_s ? ` (last read ${h.age_s}s ago)` : ""}`
+        );
+  }
+  for (const o of a.orphans)
+    if (o.note) lines.push(`pm2 \xB7 ${o.namespace}: ${o.note}`);
+  return lines.join("\n");
+}
 
 // src/core/wait.ts
 var WAIT_TIMEOUT_DEFAULT_MS = 6e4;
@@ -6331,7 +6826,7 @@ function assertNoCollision(ctx, procs, names) {
     const name2 = pm2Name(ctx.manifest.project, n);
     const expectedCwd = appCwd(ctx.host, ctx.manifest.apps[n]);
     const other = procs.find(
-      (p) => p.name === name2 && (p.namespace !== ctx.manifest.project || p.cwd !== "" && path14.posix.resolve(p.cwd) !== expectedCwd)
+      (p) => p.name === name2 && (p.namespace !== ctx.manifest.project || p.cwd !== "" && path16.posix.resolve(p.cwd) !== expectedCwd)
     );
     if (other && other.namespace !== ctx.manifest.project) {
       throw new McprocError(
@@ -6358,7 +6853,7 @@ async function shipEcosystem(ctx) {
   const eco = buildEcosystem(ctx.manifest, ctx.host);
   const file = ecosystemPath(ctx.host);
   const dir = generatedDir(ctx.host);
-  const gi = path14.posix.join(path14.posix.dirname(dir), ".gitignore");
+  const gi = path16.posix.join(path16.posix.dirname(dir), ".gitignore");
   const cmd = `mkdir -p ${shq(dir)} && { [ -e ${shq(gi)} ] || printf '*\\n' > ${shq(gi)}; } && cat > ${shq(file)}`;
   const res = ensureOk(
     await ctx.transport.exec(cmd, { stdin: JSON.stringify(eco, null, 2) }),
@@ -6535,93 +7030,7 @@ function admit(opts) {
 }
 
 // src/core/leases/siblings.ts
-import fs11 from "fs";
-
-// src/core/slots.ts
-import crypto2 from "crypto";
-import fs10 from "fs";
-import path15 from "path";
-function registryKey(baseProject, repo) {
-  return `${baseProject}-${crypto2.createHash("sha256").update(realOf(repo)).digest("hex").slice(0, 8)}`;
-}
-function registryPath(stateDir2, baseProject, repo) {
-  return path15.join(stateDir2, "slots", `${registryKey(baseProject, repo)}.json`);
-}
-function emptyRegistry(repo) {
-  return { repo, slots: {} };
-}
-function readRegistry(file) {
-  if (!fs10.existsSync(file)) return null;
-  return JSON.parse(fs10.readFileSync(file, "utf8"));
-}
-function writeRegistry(file, r) {
-  fs10.mkdirSync(path15.dirname(file), { recursive: true });
-  const tmp = `${file}.${process.pid}.tmp`;
-  fs10.writeFileSync(tmp, JSON.stringify(r, null, 2));
-  fs10.renameSync(tmp, file);
-}
-function withMain(r, entry) {
-  return { ...r, slots: { ...r.slots, "0": entry } };
-}
-function claimSlot(r, opts) {
-  if (opts.want !== void 0) {
-    if (opts.want < 1 || opts.want > opts.max)
-      throw new McprocError(
-        "BAD_ARGUMENT",
-        `slot ${opts.want} is outside 1..${opts.max} (slot 0 is the main checkout)`
-      );
-    if (Object.hasOwn(r.slots, String(opts.want)))
-      throw new McprocError(
-        "SLOT_TAKEN",
-        `slot ${opts.want} is taken by ${r.slots[String(opts.want)].path}`,
-        { hint: "Pick another slot, or remove that worktree first." }
-      );
-    return {
-      registry: { ...r, slots: { ...r.slots, [opts.want]: opts.entry } },
-      slot: opts.want
-    };
-  }
-  for (let s = 1; s <= opts.max; s++)
-    if (!Object.hasOwn(r.slots, String(s)))
-      return {
-        registry: { ...r, slots: { ...r.slots, [s]: opts.entry } },
-        slot: s
-      };
-  throw new McprocError(
-    "NO_FREE_SLOT",
-    `all ${opts.max} worktree slots of ${r.repo} are taken`,
-    {
-      hint: "Remove a worktree (worktree remove), or raise worktree.slots in the manifest."
-    }
-  );
-}
-function releaseSlot(r, slot) {
-  const slots = { ...r.slots };
-  delete slots[String(slot)];
-  return { ...r, slots };
-}
-function realOf(p) {
-  try {
-    return fs10.realpathSync(p);
-  } catch {
-    return path15.resolve(p);
-  }
-}
-function reclaimGone(r, exists) {
-  const freed = [];
-  let out = r;
-  for (const [k, e] of Object.entries(r.slots)) {
-    if (k === "0" || exists(realOf(e.path))) continue;
-    out = releaseSlot(out, Number(k));
-    freed.push(Number(k));
-  }
-  return { registry: out, freed: freed.sort((a, b) => a - b) };
-}
-function siblingsOf(r, root) {
-  return Object.entries(r.slots).filter(([, e]) => realOf(e.path) !== realOf(root)).map(([k, entry]) => ({ slot: Number(k), entry })).sort((a, b) => a.slot - b.slot);
-}
-
-// src/core/leases/siblings.ts
+import fs12 from "fs";
 var MIB = 1024 * 1024;
 var repoOf = (m) => m.repo;
 function registryOf(m, dir = stateDir()) {
@@ -6631,7 +7040,7 @@ function ownsManifest(root) {
   const found = findManifestPath(root);
   if (!found) return false;
   try {
-    return fs11.realpathSync(found.root) === fs11.realpathSync(root);
+    return fs12.realpathSync(found.root) === fs12.realpathSync(root);
   } catch {
     return false;
   }
@@ -6649,7 +7058,7 @@ async function listCheckout(root, spawner) {
 async function measureSiblings(m, deps2) {
   const out = /* @__PURE__ */ new Map();
   if (!deps2.registry) return out;
-  const exists = deps2.exists ?? ((p) => fs11.existsSync(p));
+  const exists = deps2.exists ?? ((p) => fs12.existsSync(p));
   const read = await Promise.all(
     siblingsOf(deps2.registry, m.root).filter(({ entry }) => exists(entry.path)).map(async ({ slot, entry }) => {
       try {
@@ -7040,7 +7449,15 @@ function failedRows(fleet, r, e) {
   );
 }
 async function actOn(fleet, target, act, opts = {}) {
-  const named = fleet.select([target]);
+  if (act === "start" && Array.isArray(target))
+    throw new McprocError(
+      "BAD_ARGUMENT",
+      `start takes one app or profile, not a list (${target.join(", ")})`,
+      {
+        hint: "Start one app or profile; a list of targets is for stop, restart and delete."
+      }
+    );
+  const named = fleet.select(Array.isArray(target) ? target : [target]);
   const names = act === "start" ? fleet.withDeps(named) : named;
   const runs = fleet.runs(names);
   assertWritableRuns(fleet, runs, named);
@@ -7082,6 +7499,7 @@ async function actOn(fleet, target, act, opts = {}) {
           r.apps,
           {
             target,
+            // a start of a list is refused above
             host: fleet.requested ?? null,
             reload: opts.reload,
             note: opts.note,
@@ -7148,62 +7566,586 @@ async function actOn(fleet, target, act, opts = {}) {
       rows.push(...failedRows(fleet, r, e));
     }
   }
-  if (failed && done === 0) throw failed.error;
-  const local = rows.filter((r) => pickHost(fleet.manifest, r.host).local);
-  if (act === "start" && opts.lease && local.length > 0)
-    await finishLeasedStart(gate.store, opts.lease, local);
-  return rows;
-}
-function probeFleet(fleet, names, take) {
-  return Promise.all(
-    fleet.groups(names).map(async (g) => {
-      try {
-        const ctx = await fleet.ctx(g.host);
-        return { ...g, ctx, snap: await take(ctx) };
-      } catch (e) {
-        return { ...g, error: e };
+  if (failed && done === 0) throw failed.error;
+  const local = rows.filter((r) => pickHost(fleet.manifest, r.host).local);
+  if (act === "start" && opts.lease && local.length > 0)
+    await finishLeasedStart(gate.store, opts.lease, local);
+  return rows;
+}
+function probeFleet(fleet, names, take) {
+  return Promise.all(
+    fleet.groups(names).map(async (g) => {
+      try {
+        const ctx = await fleet.ctx(g.host);
+        return { ...g, ctx, snap: await take(ctx) };
+      } catch (e) {
+        return { ...g, error: e };
+      }
+    })
+  );
+}
+async function listFleet(fleet, names, opts = {}) {
+  const probes = await probeFleet(
+    fleet,
+    names,
+    (ctx) => snapshot(ctx, { urls: names, ...opts })
+  );
+  const failed = probes.filter((p) => p.error !== void 0);
+  if (failed.length === probes.length && failed.length > 0)
+    throw failed[0].error;
+  const byApp = /* @__PURE__ */ new Map();
+  for (const p of probes) {
+    const rows = p.snap ? rowsFor(p.ctx, p.snap, p.apps) : p.apps.map(
+      (a) => unreachableRow(fleet.manifest.apps[a], p.host, describeError(p.error))
+    );
+    for (const r of rows) byApp.set(r.app, r);
+  }
+  return {
+    rows: names.map((n) => byApp.get(n)),
+    errors: failed.map((p) => ({
+      host: p.host,
+      apps: p.apps,
+      message: describeError(p.error)
+    })),
+    probes
+  };
+}
+async function describeFleetApp(fleet, app) {
+  const host = fleet.one(app);
+  const d = await describeApp(await fleet.ctx(host), app);
+  const full = fleet.manifest.apps[app];
+  return {
+    ...d,
+    app: { ...full, depends_on: full.depends_on.map(depView) },
+    host
+  };
+}
+
+// src/core/stacks/discover.ts
+function endpointKey(host) {
+  const args = host.ssh && host.ssh_args.length ? ` [${host.ssh_args.join(" ")}]` : "";
+  return `${describeHost(host)}${args}|${host.pm2_home ?? ""}`;
+}
+function endpointLabel(host) {
+  if (!host.local) return host.name;
+  return host.pm2_home ? `local (${host.pm2_home})` : "local";
+}
+var claimKey = (endpoint, namespace) => `${endpoint}\0${namespace}`;
+var under = (p, root) => p === root || p.startsWith(root.endsWith("/") ? root : `${root}/`);
+var bare = (dir) => dir.replace(/(.)\/+$/, "$1");
+function cwdsOn(p, key) {
+  const m = p.manifest;
+  if (!m) return [bare(p.root)];
+  return Object.entries(p.endpoints).filter(([name2, k]) => k === key && Object.hasOwn(m.hosts, name2)).map(([name2]) => bare(m.hosts[name2].cwd));
+}
+function ownProcs(p, key, procs, claimants) {
+  const mine = procs.filter((pr) => pr.namespace === p.project);
+  if (claimants.length < 2) return mine;
+  const dirs = claimants.flatMap(
+    (c) => cwdsOn(c, key).map((dir) => ({ c, dir }))
+  );
+  return mine.filter((pr) => {
+    let best = -1;
+    let owners = /* @__PURE__ */ new Set();
+    for (const d of dirs) {
+      if (!under(pr.cwd, d.dir) || d.dir.length < best) continue;
+      if (d.dir.length > best) {
+        best = d.dir.length;
+        owners = /* @__PURE__ */ new Set();
+      }
+      owners.add(d.c);
+    }
+    return owners.size === 1 && owners.has(p);
+  });
+}
+function stackError(e) {
+  if (!isMcprocError(e)) return { code: "ERROR", message: describeError(e) };
+  return e.hint ? { code: e.code, message: e.message, hint: e.hint } : { code: e.code, message: e.message };
+}
+function procMemory(p, probe) {
+  if (p.pid <= 0) return p.memory;
+  const set = descendants2(probe.data.tree, p.pid);
+  set.add(p.pid);
+  return treeMetrics(set, probe.data.stats, probe.data.listeners)?.memory ?? p.memory;
+}
+var ERRORED = (s) => s === "errored" || s.startsWith("failed");
+var STOPPED = (s) => s === "stopped" || s === "done";
+function counts(statuses, queued) {
+  return {
+    total: statuses.length,
+    online: statuses.filter((s) => s === "online").length,
+    errored: statuses.filter(ERRORED).length,
+    stopped: statuses.filter(STOPPED).length,
+    queued
+  };
+}
+function summary(rows) {
+  const online = rows.filter((r) => r.status === "online");
+  const queued = rows.flatMap(
+    (r) => r.lease?.state === "pending" ? [r.lease.position] : []
+  );
+  const cpus = online.flatMap((r) => r.cpu === null ? [] : [r.cpu]);
+  return {
+    apps: counts(
+      rows.map((r) => r.status),
+      queued.length
+    ),
+    queue_position: queued.length ? Math.min(...queued) : null,
+    memory: online.reduce((a, r) => a + r.memory, 0),
+    cpu: cpus.length ? cpus.reduce((a, b) => a + b, 0) : null,
+    ports: online.flatMap(
+      (r) => [...new Set(r.ports.actual.map((l) => l.port))].sort((a, b) => a - b).map((port) => ({ app: r.app, port }))
+    ),
+    present: rows.some((r) => r.pm_id !== null || r.lease !== void 0)
+  };
+}
+async function buildStacks(projects, reads, opts) {
+  const claims = /* @__PURE__ */ new Map();
+  for (const p of projects)
+    for (const key of new Set(Object.values(p.endpoints))) {
+      const k = claimKey(key, p.project);
+      claims.set(k, [...claims.get(k) ?? [], p]);
+    }
+  const stacks = [];
+  for (const p of projects) stacks.push(await stackOf(p, reads, claims, opts));
+  const orphans = [];
+  for (const r of reads.values()) {
+    const probe = r.probe;
+    if (!probe) continue;
+    const byNs = /* @__PURE__ */ new Map();
+    for (const pr of probe.procs)
+      byNs.set(pr.namespace, [...byNs.get(pr.namespace) ?? [], pr]);
+    for (const [ns, procs] of byNs) {
+      if (ns === WATCHER_NS || claims.has(claimKey(r.key, ns))) continue;
+      orphans.push({
+        namespace: ns,
+        endpoint: r.label,
+        processes: procs.map((pr) => ({
+          name: pr.name,
+          status: pr.status,
+          memory: procMemory(pr, probe)
+        })),
+        note: opts.orphanNotes?.get(claimKey(r.key, ns)) ?? null
+      });
+    }
+  }
+  orphans.sort(
+    (a, b) => a.endpoint.localeCompare(b.endpoint) || a.namespace.localeCompare(b.namespace)
+  );
+  return { stacks, orphans };
+}
+async function stackOf(p, reads, claims, opts) {
+  const hosts = Object.entries(p.endpoints).map(([name2, key]) => {
+    const r = reads.get(key);
+    return {
+      name: name2,
+      endpoint: r?.label ?? key,
+      reachable: Boolean(r?.probe) && !r?.error,
+      error: r?.error ?? null,
+      age_s: r?.age_s ?? 0
+    };
+  });
+  const claimantsOn = (key) => claims.get(claimKey(key, p.project)) ?? [];
+  const shared = Math.max(
+    0,
+    ...Object.values(p.endpoints).map((k) => claimantsOn(k).length)
+  );
+  const notes = shared > 1 ? [`slug shared by ${shared} checkouts`] : [];
+  const rivals = [
+    ...new Set(
+      Object.values(p.endpoints).flatMap((k) => claimantsOn(k)).filter((c) => c !== p).map((c) => c.root)
+    )
+  ];
+  const fromNamespace = (error) => {
+    const key = p.endpoints.local;
+    const probe = key ? reads.get(key)?.probe : void 0;
+    const procs = probe ? ownProcs(p, key, probe.procs, claimantsOn(key)) : [];
+    return {
+      ...identity(p),
+      hosts,
+      apps: counts(
+        procs.map((x) => x.status),
+        0
+      ),
+      queue_position: null,
+      memory: probe ? procs.reduce((a, x) => a + procMemory(x, probe), 0) : 0,
+      cpu: null,
+      ports: [],
+      manifest_error: error,
+      notes,
+      present: procs.length > 0,
+      rows: [],
+      rivals
+    };
+  };
+  if (!p.manifest) return fromNamespace(p.error);
+  let rows;
+  try {
+    rows = await manifestRows(p, p.manifest, reads, claimantsOn, opts);
+  } catch (e) {
+    return fromNamespace(stackError(e));
+  }
+  return {
+    ...identity(p),
+    hosts,
+    ...summary(rows),
+    manifest_error: null,
+    notes,
+    rows,
+    rivals
+  };
+}
+async function manifestRows(p, m, reads, claimantsOn, opts) {
+  const byApp = /* @__PURE__ */ new Map();
+  for (const g of new Fleet(m, void 0).groups(Object.keys(m.apps))) {
+    const key = p.endpoints[g.host];
+    const r = key ? reads.get(key) : void 0;
+    let rows;
+    if (!r?.probe) {
+      rows = g.apps.map(
+        (a) => unreachableRow(m.apps[a], g.host, r?.error ?? "not probed yet")
+      );
+    } else {
+      const claimants = claimantsOn(key);
+      const probe = claimants.length < 2 ? r.probe : {
+        ...r.probe,
+        procs: [
+          ...r.probe.procs.filter((pr) => pr.namespace !== p.project),
+          ...ownProcs(p, key, r.probe.procs, claimants)
+        ]
+      };
+      const view = {
+        manifest: scopeManifest(m, g.host, "local"),
+        host: pickHost(m, g.host),
+        hereCheck: opts.hereCheck
+      };
+      const snap = await deriveSnapshot(view, probe, {
+        urls: "none",
+        prev: opts.prev?.get(key)
+      });
+      rows = rowsFor(view, snap, g.apps);
+    }
+    for (const row of rows) byApp.set(row.app, row);
+  }
+  return Object.keys(m.apps).map((a) => byApp.get(a));
+}
+function identity(p) {
+  return {
+    project: p.project,
+    root: p.root,
+    base_project: p.manifest?.base_project ?? p.project,
+    slot: p.slot,
+    branch: p.branch,
+    source: p.source
+  };
+}
+function orderStacks(stacks, all) {
+  const shown = stacks.filter((s) => all || s.present);
+  const names = new Set(shown.map((s) => s.project));
+  const child = (s) => s.base_project !== s.project && names.has(s.base_project);
+  const bases = shown.filter((s) => !child(s)).sort(
+    (a, b) => Number(b.apps.online > 0) - Number(a.apps.online > 0) || a.project.localeCompare(b.project)
+  );
+  const placed = /* @__PURE__ */ new Set();
+  return bases.flatMap((b) => {
+    if (placed.has(b.project)) return [b];
+    placed.add(b.project);
+    return [
+      b,
+      ...shown.filter((s) => child(s) && s.base_project === b.project).sort((x, y) => (x.slot ?? 0) - (y.slot ?? 0))
+    ];
+  });
+}
+
+// src/core/stacks/collect.ts
+var REMOTE_EVERY_MS = 1e4;
+var RETRY_MS = 3e4;
+var REGISTRY_EVERY = 10;
+var ASK = {
+  cpuSample: false,
+  metrics: true,
+  urls: [],
+  containers: []
+};
+var FIRST_ASK = { ...ASK, cpuSample: true };
+function defaultCollectorDeps(spawner) {
+  return {
+    stateDir: stateDir(),
+    now: Date.now,
+    connectHost: (host) => connectHost(host, { spawner }),
+    probeHost,
+    loadManifest,
+    findManifest: findManifestPath,
+    hostname: os8.hostname,
+    hereCheck: checkHere
+  };
+}
+var short = (e) => describeError(e).split("\n")[0].slice(0, 120);
+var StacksCollector = class {
+  constructor(deps2 = defaultCollectorDeps()) {
+    this.deps = deps2;
+  }
+  deps;
+  known = [];
+  refreshes = 0;
+  registryError = null;
+  local = bareLocalHost();
+  localKey = endpointKey(this.local);
+  /** the host each endpoint is reached through: the first checkout naming it gives it; local's is the bare one */
+  hosts = /* @__PURE__ */ new Map();
+  /** the real roots of the checkouts this collector found on the daemon: they stay daemon-found for its life */
+  adopted = /* @__PURE__ */ new Set();
+  /** the walks that made no stack, by namespace and cwd, with the note each leaves; cleared with each registry read */
+  misses = /* @__PURE__ */ new Map();
+  links = /* @__PURE__ */ new Map();
+  cache = /* @__PURE__ */ new Map();
+  async collect(opts) {
+    if (this.refreshes % REGISTRY_EVERY === 0) this.known = this.readKnown();
+    this.refreshes++;
+    const reads = /* @__PURE__ */ new Map();
+    await this.readAll(reads);
+    const notes = this.adopt(reads.get(this.localKey));
+    await this.readAll(reads);
+    const prev = /* @__PURE__ */ new Map();
+    for (const key of reads.keys()) {
+      const p = this.cache.get(key)?.prev;
+      if (p) prev.set(key, p);
+    }
+    const built = await buildStacks(this.known, reads, {
+      all: opts.all,
+      hereCheck: this.deps.hereCheck,
+      prev,
+      orphanNotes: notes
+    });
+    const stacks = orderStacks(built.stacks, opts.all);
+    const localRead = reads.get(this.localKey);
+    const watcher = localRead?.probe?.procs.find(
+      (p) => p.name === WATCHER_NAME && p.namespace === WATCHER_NS
+    );
+    const mem = localRead?.probe?.data.memory ?? null;
+    let queue = 0;
+    try {
+      queue = new LeaseStore(this.deps.stateDir).list().filter((l) => l.state === "pending").length;
+    } catch {
+    }
+    const answer = {
+      host: {
+        name: this.deps.hostname(),
+        memory: mem ? { available_mib: mem.available_mib, total_mib: mem.total_mib } : null,
+        watcher: watcher ? {
+          online: watcher.status === "online",
+          pid: watcher.pid > 0 ? watcher.pid : null
+        } : null,
+        queue,
+        notes: [
+          this.registryError ? `registry unreadable: ${this.registryError}` : "",
+          localRead?.error ? `local pm2: ${localRead.error}` : ""
+        ].filter(Boolean)
+      },
+      stacks: stacks.map(({ rows: _rows, rivals: _rivals, ...s }) => s),
+      orphans: built.orphans
+    };
+    const manifests = new Map(
+      this.known.flatMap(
+        (p) => p.manifest ? [[p.root, p.manifest]] : []
+      )
+    );
+    return { answer, stacks, manifests };
+  }
+  /** Reads every endpoint the known checkouts need, and the local daemon: those not read yet this refresh. */
+  async readAll(reads) {
+    const keys = /* @__PURE__ */ new Set([
+      this.localKey,
+      ...this.known.flatMap((p) => Object.values(p.endpoints))
+    ]);
+    await Promise.all(
+      [...keys].filter((key) => !reads.has(key)).map(async (key) => {
+        const host = this.hosts.get(key);
+        if (host) reads.set(key, await this.read(key, host));
+      })
+    );
+  }
+  /** One endpoint's answer: a fresh probe when it is due, else (or when the probe fails) the last data with its age. */
+  async read(key, host) {
+    const now = this.deps.now();
+    const c = this.cache.get(key);
+    const answer = (e) => ({
+      key,
+      label: endpointLabel(host),
+      probe: e.probe,
+      error: e.error,
+      age_s: e.probe ? Math.round((now - e.at) / 1e3) : 0
+    });
+    if (c && now < c.next) return answer(c);
+    let entry;
+    try {
+      let link = this.links.get(key);
+      if (!link) {
+        link = this.deps.connectHost(host);
+        this.links.set(key, link);
+      }
+      const last = c?.probe;
+      const probe = await this.deps.probeHost(
+        await link,
+        last ? ASK : FIRST_ASK
+      );
+      const sample = last?.data.stats.samples.at(-1);
+      entry = {
+        probe,
+        prev: last && sample ? { sample, at: last.sampledAt } : void 0,
+        error: null,
+        at: now,
+        next: host.local ? now : now + REMOTE_EVERY_MS
+      };
+    } catch (e) {
+      this.links.delete(key);
+      entry = {
+        probe: c?.probe ?? null,
+        prev: c?.prev,
+        error: short(e),
+        at: c?.at ?? now,
+        next: host.local ? now : now + RETRY_MS
+      };
+    }
+    this.cache.set(key, entry);
+    return answer(entry);
+  }
+  /** The checkouts the registry records, one per real root; an entry whose project changed follows its manifest. */
+  readKnown() {
+    const { entries, error } = listProjects(this.deps.stateDir);
+    this.registryError = error;
+    this.hosts = /* @__PURE__ */ new Map([[this.localKey, this.local]]);
+    this.misses.clear();
+    const byRoot = /* @__PURE__ */ new Map();
+    for (const e of entries) {
+      const source = this.adopted.has(realOf(e.root)) ? "daemon" : "registry";
+      let m;
+      try {
+        m = this.deps.loadManifest(e.root);
+      } catch (err) {
+        byRoot.set(realOf(e.root), this.broken(e.project, e.root, source, err));
+        continue;
+      }
+      if (m.project !== e.project) {
+        forgetProject(e.project, e.root, this.deps.stateDir);
+        recordProject(m, this.deps.stateDir);
+      }
+      byRoot.set(realOf(m.root), this.inputOf(m, source));
+    }
+    return [...byRoot.values()];
+  }
+  /** A checkout without a usable manifest: its error, and its namespace on the local daemon for what runs. */
+  broken(project, root, source, e) {
+    return {
+      project,
+      root,
+      source,
+      manifest: null,
+      error: stackError(e),
+      endpoints: { local: this.localKey },
+      slot: null,
+      branch: null
+    };
+  }
+  /** A loaded checkout with its hosts' endpoints and its slot; one whose endpoints cannot be built carries the error. */
+  inputOf(m, source) {
+    const endpoints = {};
+    const hosts = /* @__PURE__ */ new Map();
+    try {
+      for (const g of new Fleet(m, void 0).groups(Object.keys(m.apps))) {
+        const host = pickHost(m, g.host);
+        endpoints[g.host] = endpointKey(host);
+        hosts.set(endpoints[g.host], host);
+      }
+    } catch (e) {
+      return this.broken(m.project, m.root, source, e);
+    }
+    for (const [key, host] of hosts)
+      if (!this.hosts.has(key)) this.hosts.set(key, host);
+    let slot = m.slot;
+    let branch = null;
+    try {
+      const reg = readRegistry(
+        registryPath(this.deps.stateDir, m.base_project, m.repo)
+      );
+      const hit = reg && Object.entries(reg.slots).find(
+        ([, s]) => realOf(s.path) === realOf(m.root)
+      );
+      if (hit) {
+        slot = Number(hit[0]);
+        branch = hit[1].branch;
+      }
+    } catch {
+    }
+    return {
+      project: m.project,
+      root: m.root,
+      source,
+      manifest: m,
+      error: null,
+      endpoints,
+      slot,
+      branch
+    };
+  }
+  /**
+   * The local daemon's namespaces no known checkout claims: a manifest above a process's cwd that names the namespace
+   * makes it a stack, recorded from then on. One that names another project, or does not load, leaves a note on the
+   * orphan; a checkout known already (its apps run elsewhere) is never a second stack. A walk that made no stack is
+   * kept with its note until the registry is read again: a refresh does not parse the same manifest twice.
+   */
+  adopt(read) {
+    const notes = /* @__PURE__ */ new Map();
+    if (!read?.probe) return notes;
+    const claimed = new Set(
+      this.known.filter((p) => Object.values(p.endpoints).includes(this.localKey)).map((p) => p.project)
+    );
+    const roots = new Set(this.known.map((p) => realOf(p.root)));
+    const cwds = /* @__PURE__ */ new Map();
+    for (const p of read.probe.procs)
+      if (p.cwd && p.namespace !== WATCHER_NS && !claimed.has(p.namespace))
+        cwds.set(p.namespace, (cwds.get(p.namespace) ?? /* @__PURE__ */ new Set()).add(p.cwd));
+    for (const [ns, dirs] of cwds) {
+      const note = claimKey(this.localKey, ns);
+      for (const cwd of dirs) {
+        const missed = `${ns}\0${cwd}`;
+        const r = this.misses.has(missed) ? { note: this.misses.get(missed) ?? null } : this.walk(ns, cwd, roots);
+        if ("manifest" in r) {
+          const real = realOf(r.manifest.root);
+          recordProject(r.manifest, this.deps.stateDir);
+          this.adopted.add(real);
+          roots.add(real);
+          this.known.push(this.inputOf(r.manifest, "daemon"));
+          notes.delete(note);
+          break;
+        }
+        this.misses.set(missed, r.note);
+        if (r.note !== null) notes.set(note, r.note);
       }
-    })
-  );
-}
-async function listFleet(fleet, names, opts = {}) {
-  const probes = await probeFleet(
-    fleet,
-    names,
-    (ctx) => snapshot(ctx, { urls: names, ...opts })
-  );
-  const failed = probes.filter((p) => p.error !== void 0);
-  if (failed.length === probes.length && failed.length > 0)
-    throw failed[0].error;
-  const byApp = /* @__PURE__ */ new Map();
-  for (const p of probes) {
-    const rows = p.snap ? rowsFor(p.ctx, p.snap, p.apps) : p.apps.map(
-      (a) => unreachableRow(fleet.manifest.apps[a], p.host, describeError(p.error))
-    );
-    for (const r of rows) byApp.set(r.app, r);
+    }
+    return notes;
   }
-  return {
-    rows: names.map((n) => byApp.get(n)),
-    errors: failed.map((p) => ({
-      host: p.host,
-      apps: p.apps,
-      message: describeError(p.error)
-    })),
-    probes
-  };
-}
-async function describeFleetApp(fleet, app) {
-  const host = fleet.one(app);
-  const d = await describeApp(await fleet.ctx(host), app);
-  const full = fleet.manifest.apps[app];
-  return {
-    ...d,
-    app: { ...full, depends_on: full.depends_on.map(depView) },
-    host
-  };
-}
+  /** The walk up from one cwd of namespace `ns`: the manifest that makes it a stack, or the note it leaves (null: none). */
+  walk(ns, cwd, roots) {
+    const found = this.deps.findManifest(cwd);
+    if (!found) return { note: null };
+    let m;
+    try {
+      m = this.deps.loadManifest(found.root);
+    } catch (e) {
+      return { note: `manifest at ${found.path}: ${stackError(e).code}` };
+    }
+    if (m.project !== ns)
+      return { note: `manifest at ${found.path} names ${m.project}` };
+    if (roots.has(realOf(m.root))) return { note: null };
+    return { manifest: m };
+  }
+};
 
 // src/core/leases/watcher.ts
+import { spawn as spawn2 } from "child_process";
+import fs13 from "fs";
+import path17 from "path";
 async function moveIf(store, id, from, to, patch = {}, also = () => true) {
   return store.withLock(async () => {
     const cur = store.get(id);
@@ -7396,13 +8338,13 @@ async function leaveIdle(deps2) {
   return store.withLock(() => {
     if (store.list().some((l) => l.state === "pending" || l.state === "starting"))
       return false;
-    const file = path16.join(path16.dirname(store.dir), WATCHER_NOTE);
+    const file = path17.join(path17.dirname(store.dir), WATCHER_NOTE);
     const tmp = `${file}.${process.pid}.tmp`;
-    fs12.writeFileSync(
+    fs13.writeFileSync(
       tmp,
       JSON.stringify({ exiting_at: new Date(deps2.now()).toISOString() })
     );
-    fs12.renameSync(tmp, file);
+    fs13.renameSync(tmp, file);
     return true;
   });
 }
@@ -7513,7 +8455,7 @@ async function watchLeases(deps2, opts = {}) {
 }
 function leaseDirWatch(dir) {
   return (cb) => {
-    const w = fs12.watch(dir, (_e, name2) => {
+    const w = fs13.watch(dir, (_e, name2) => {
       if (!name2?.startsWith(".")) cb();
     });
     return () => w.close();
@@ -7876,8 +8818,8 @@ async function runExec(ctx, opts, deps2) {
 
 // src/core/worktree.ts
 import { execFile } from "child_process";
-import fs13 from "fs";
-import path17 from "path";
+import fs14 from "fs";
+import path18 from "path";
 var gitRunner = (args, cwd) => new Promise((resolve) => {
   execFile(
     "git",
@@ -7902,7 +8844,7 @@ var gitOk = async (git, args, cwd) => {
 };
 var present = (p) => {
   try {
-    fs13.lstatSync(p);
+    fs14.lstatSync(p);
     return true;
   } catch {
     return false;
@@ -7910,15 +8852,15 @@ var present = (p) => {
 };
 async function mainCheckout(root, git) {
   const common = (await gitOk(git, ["rev-parse", "--git-common-dir"], root)).trim();
-  return fs13.realpathSync(path17.dirname(path17.resolve(root, common)));
+  return fs14.realpathSync(path18.dirname(path18.resolve(root, common)));
 }
 function worktreeDir(m, main) {
-  return m.worktree.dir ? path17.resolve(main, m.worktree.dir) : `${main}.worktrees`;
+  return m.worktree.dir ? path18.resolve(main, m.worktree.dir) : `${main}.worktrees`;
 }
 function installCommand(m, root) {
   if (m.worktree.install === false) return null;
   if (typeof m.worktree.install === "string") return m.worktree.install;
-  const has = (f) => fs13.existsSync(path17.join(root, f));
+  const has = (f) => fs14.existsSync(path18.join(root, f));
   if (has("bun.lock") || has("bun.lockb")) return "bun install";
   if (has("yarn.lock")) return "yarn install";
   if (has("pnpm-lock.yaml")) return "pnpm install";
@@ -7926,22 +8868,22 @@ function installCommand(m, root) {
   return null;
 }
 function planCopies(main, target, copy, link, fsDeps = {}) {
-  const exists = fsDeps.exists ?? ((p) => fs13.existsSync(p));
-  const glob = fsDeps.glob ?? ((pattern, cwd) => fs13.globSync(pattern, { cwd }));
+  const exists = fsDeps.exists ?? ((p) => fs14.existsSync(p));
+  const glob = fsDeps.glob ?? ((pattern, cwd) => fs14.globSync(pattern, { cwd }));
   const copies = [];
   const missing = [];
   for (const entry of copy) {
-    const hits2 = /[*?[]/.test(entry) ? glob(entry, main).sort() : exists(path17.join(main, entry)) ? [entry] : [];
+    const hits2 = /[*?[]/.test(entry) ? glob(entry, main).sort() : exists(path18.join(main, entry)) ? [entry] : [];
     if (hits2.length === 0) {
       missing.push(entry);
       continue;
     }
     for (const h of hits2)
-      copies.push({ from: path17.join(main, h), to: path17.join(target, h) });
+      copies.push({ from: path18.join(main, h), to: path18.join(target, h) });
   }
   const links = link.map((l) => ({
-    from: path17.join(main, l),
-    to: path17.join(target, l)
+    from: path18.join(main, l),
+    to: path18.join(target, l)
   }));
   return { copies, links, missing };
 }
@@ -7957,7 +8899,7 @@ function ownManifest(target, log, instead) {
   }
 }
 function excludePattern(rel) {
-  const p = path17.posix.normalize(rel.split(path17.sep).join("/")).replace(/\/+$/, "");
+  const p = path18.posix.normalize(rel.split(path18.sep).join("/")).replace(/\/+$/, "");
   if (p === "." || p === "" || p === ".." || p.startsWith("../") || p.startsWith("/"))
     return null;
   return `/${p.replace(/[\\*?[\]]/g, (c) => `\\${c}`).replace(/ $/, "\\ ")}`;
@@ -7981,13 +8923,13 @@ async function excludeLinks(target, links, git, log) {
     );
     return [];
   }
-  const file = path17.resolve(target, r.stdout.trim());
-  fs13.mkdirSync(path17.dirname(file), { recursive: true });
-  const had = fs13.existsSync(file) ? fs13.readFileSync(file, "utf8") : "";
+  const file = path18.resolve(target, r.stdout.trim());
+  fs14.mkdirSync(path18.dirname(file), { recursive: true });
+  const had = fs14.existsSync(file) ? fs14.readFileSync(file, "utf8") : "";
   const lines = new Set(had.split("\n"));
   const add2 = patterns.filter((p) => !lines.has(p));
   if (add2.length)
-    fs13.appendFileSync(
+    fs14.appendFileSync(
       file,
       `${had.length && !had.endsWith("\n") ? "\n" : ""}${add2.join("\n")}
 `
@@ -8003,7 +8945,7 @@ function registryFor(m, main, mainBranch, deps2) {
   });
   const { registry, freed } = reclaimGone(
     read,
-    deps2.exists ?? ((p) => fs13.existsSync(p))
+    deps2.exists ?? ((p) => fs14.existsSync(p))
   );
   for (const s of freed) deps2.log(`slot ${s} reclaimed: its checkout is gone`);
   return { file, registry };
@@ -8033,12 +8975,12 @@ async function worktreeList(main, git) {
 }
 function realAhead(p) {
   const rest = [];
-  let d = path17.resolve(p);
-  while (!present(d) && path17.dirname(d) !== d) {
-    rest.unshift(path17.basename(d));
-    d = path17.dirname(d);
+  let d = path18.resolve(p);
+  while (!present(d) && path18.dirname(d) !== d) {
+    rest.unshift(path18.basename(d));
+    d = path18.dirname(d);
   }
-  return path17.join(realOf(d), ...rest);
+  return path18.join(realOf(d), ...rest);
 }
 var shPath = (p) => /^[\w./@%+:-]+$/.test(p) ? p : shq(p);
 async function worktreeAdd(m, opts, deps2) {
@@ -8075,7 +9017,7 @@ async function worktreeAdd(m, opts, deps2) {
         }
       );
   const target = realAhead(
-    path17.join(worktreeDir(m, main), ...opts.branch.split("/"))
+    path18.join(worktreeDir(m, main), ...opts.branch.split("/"))
   );
   const taken = () => new McprocError("WORKTREE_EXISTS", `${target} exists already`, {
     hint: "Remove it, or pick another branch name."
@@ -8098,9 +9040,9 @@ async function worktreeAdd(m, opts, deps2) {
           `project slug ${project2} is the slug of slot ${k} (${e.path})`,
           { hint: "Pass another project slug." }
         );
-    fs13.mkdirSync(path17.dirname(target), { recursive: true });
+    fs14.mkdirSync(path18.dirname(target), { recursive: true });
     try {
-      fs13.mkdirSync(target);
+      fs14.mkdirSync(target);
     } catch (e) {
       if (e.code === "EEXIST") throw taken();
       throw e;
@@ -8135,7 +9077,7 @@ async function worktreeAdd(m, opts, deps2) {
     );
   } catch (e) {
     try {
-      fs13.rmdirSync(target);
+      fs14.rmdirSync(target);
     } catch {
     }
     await store.withLock(() => {
@@ -8155,8 +9097,8 @@ async function worktreeAdd(m, opts, deps2) {
     repo: main,
     vars: (probe ?? m).slot !== null ? { slot } : void 0
   });
-  const gi = path17.join(target, ".mcproc", ".gitignore");
-  if (!present(gi)) fs13.writeFileSync(gi, "*\n");
+  const gi = path18.join(target, ".mcproc", ".gitignore");
+  if (!present(gi)) fs14.writeFileSync(gi, "*\n");
   const own2 = probe ? ownManifest(target, deps2.log, "the copies and the install") : null;
   const dm = own2 ?? m;
   const only = (xs, not) => [...new Set(xs)].filter((e) => !not.includes(e));
@@ -8186,15 +9128,15 @@ async function worktreeAdd(m, opts, deps2) {
     missing: [...ownPlan.missing, ...extraPlan.missing]
   };
   const fromOverride = [
-    ...addedCopies.map((c) => path17.relative(main, c.from)),
-    ...addedLinks.map((l) => path17.relative(main, l.from))
+    ...addedCopies.map((c) => path18.relative(main, c.from)),
+    ...addedLinks.map((l) => path18.relative(main, l.from))
   ];
   let step = "";
   try {
     for (const c of plan.copies) {
       step = `copying ${c.from}`;
-      fs13.mkdirSync(path17.dirname(c.to), { recursive: true });
-      fs13.cpSync(c.from, c.to, {
+      fs14.mkdirSync(path18.dirname(c.to), { recursive: true });
+      fs14.cpSync(c.from, c.to, {
         recursive: true,
         force: false,
         errorOnExist: false
@@ -8202,8 +9144,8 @@ async function worktreeAdd(m, opts, deps2) {
     }
     for (const l of plan.links) {
       step = `linking ${l.from}`;
-      fs13.mkdirSync(path17.dirname(l.to), { recursive: true });
-      if (!present(l.to)) fs13.symlinkSync(l.from, l.to);
+      fs14.mkdirSync(path18.dirname(l.to), { recursive: true });
+      if (!present(l.to)) fs14.symlinkSync(l.from, l.to);
     }
   } catch (e) {
     throw new McprocError(
@@ -8218,7 +9160,7 @@ async function worktreeAdd(m, opts, deps2) {
     deps2.log(`copy: ${miss} is not in ${main}, skipped`);
   const excluded = await excludeLinks(
     target,
-    plan.links.map((l) => path17.relative(target, l.to)),
+    plan.links.map((l) => path18.relative(target, l.to)),
     deps2.git,
     deps2.log
   );
@@ -8247,8 +9189,8 @@ async function worktreeAdd(m, opts, deps2) {
     project,
     repo: main,
     manifest: own2 ? "worktree" : "main",
-    copied: plan.copies.map((c) => path17.relative(main, c.from)),
-    linked: plan.links.map((l) => path17.relative(main, l.from)),
+    copied: plan.copies.map((c) => path18.relative(main, c.from)),
+    linked: plan.links.map((l) => path18.relative(main, l.from)),
     from_override: fromOverride,
     excluded,
     missing: plan.missing,
@@ -8265,7 +9207,7 @@ async function worktreeLs(m, deps2) {
     branch: await currentBranch(main, deps2.git),
     project: m.base_project
   });
-  const exists = deps2.exists ?? ((p) => fs13.existsSync(p));
+  const exists = deps2.exists ?? ((p) => fs14.existsSync(p));
   const branches = await worktreeList(main, deps2.git);
   const procs = await deps2.jlist();
   const leases = new LeaseStore(deps2.stateDir).list();
@@ -8315,7 +9257,7 @@ async function worktreeRemove(m, ref, opts, deps2) {
   if (!(await worktreeList(main, deps2.git)).has(realOf(e.path))) {
     let empty = false;
     try {
-      empty = fs13.readdirSync(e.path).length === 0;
+      empty = fs14.readdirSync(e.path).length === 0;
     } catch {
     }
     if (!empty)
@@ -8324,7 +9266,7 @@ async function worktreeRemove(m, ref, opts, deps2) {
         `${e.path} (slot ${k}) is no git worktree of ${main}`,
         { hint: "Look at what is in it, remove it by hand, then worktree ls." }
       );
-    fs13.rmdirSync(e.path);
+    fs14.rmdirSync(e.path);
     deps2.log(`${e.path} was an empty folder git never filled: removed`);
     await free();
     return { path: e.path, slot: Number(k), branch: e.branch, stopped: [] };
@@ -8345,14 +9287,15 @@ async function worktreeRemove(m, ref, opts, deps2) {
     main
   );
   const top = realOf(worktreeDir(m, main));
-  for (let d = path17.dirname(e.path); d.startsWith(`${top}${path17.sep}`); d = path17.dirname(d)) {
+  for (let d = path18.dirname(e.path); d.startsWith(`${top}${path18.sep}`); d = path18.dirname(d)) {
     try {
-      fs13.rmdirSync(d);
+      fs14.rmdirSync(d);
     } catch {
       break;
     }
   }
   await free();
+  forgetProject(e.project, e.path, deps2.stateDir);
   return { path: e.path, slot: Number(k), branch: e.branch, stopped };
 }
 async function stopCheckout(root, opts) {
@@ -8412,10 +9355,10 @@ async function defaultWorktreeDeps(ctx, io, opts = {}) {
 }
 
 // src/core/incidents/store.ts
-import fs14 from "fs";
+import fs15 from "fs";
 import { createHash as createHash3, randomUUID } from "crypto";
 import net from "net";
-import path18 from "path";
+import path19 from "path";
 
 // src/core/incidents/taken.ts
 function takenPoints(s) {
@@ -8485,16 +9428,16 @@ async function pollIncidents(fleet, names, opts = {}) {
           };
         const files = targets.flatMap(
           (t) => STREAMS2.map((stream) => {
-            const path22 = stream === "out" ? t.p.out_log : t.p.err_log;
+            const path23 = stream === "out" ? t.p.out_log : t.p.err_log;
             const mark = t.prev?.[stream];
-            const same = mark && mark.path === path22;
+            const same = mark && mark.path === path23;
             const emptied = opts.restart?.[markKey(g.host, t.app)]?.[stream];
-            const restarted = !!emptied && (emptied.includes(path22) || emptied.includes("*"));
+            const restarted = !!emptied && (emptied.includes(path23) || emptied.includes("*"));
             const anchor = !restarted && same && mark.at !== void 0 && mark.anchor !== void 0 ? { at: mark.at, hex: mark.anchor } : null;
             return {
               t,
               stream,
-              path: path22,
+              path: path23,
               offset: restarted ? 0 : same ? mark.offset : null,
               anchor,
               restarted
@@ -8758,7 +9701,7 @@ function processEvents(app, host, p, prev, errLines) {
 }
 
 // src/core/incidents/store.ts
-var fileClearKey = (key, stream, path22) => `${key}\0${stream}\0${path22}`;
+var fileClearKey = (key, stream, path23) => `${key}\0${stream}\0${path23}`;
 var countedClearKey = (key) => `${key}\0counted`;
 var isAppClearKey = (k) => !k.includes("\0");
 function parseFileClearKey(k) {
@@ -8767,13 +9710,13 @@ function parseFileClearKey(k) {
   return { key, stream, path: rest.join("\0") };
 }
 var LOCK_WAIT_MS2 = 3e4;
-var storePath = (manifestPath) => path18.join(path18.dirname(manifestPath), "incidents.json");
+var storePath = (manifestPath) => path19.join(path19.dirname(manifestPath), "incidents.json");
 var pad = (n) => String(n).padStart(2, "0");
 var localStamp = (d) => `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}T${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
 function readStore(file) {
   try {
     const s = JSON.parse(
-      fs14.readFileSync(file, "utf8")
+      fs15.readFileSync(file, "utf8")
     );
     const obj = (o) => typeof o === "object" && o !== null ? o : {};
     if (s && s.v === 1 && typeof s.apps === "object" && s.apps !== null)
@@ -8788,12 +9731,12 @@ function readStore(file) {
   return { v: 1, apps: {}, cleared: {}, clears: {} };
 }
 function lockAddress(file) {
-  let dir = path18.dirname(path18.resolve(file));
+  let dir = path19.dirname(path19.resolve(file));
   try {
-    dir = fs14.realpathSync(dir);
+    dir = fs15.realpathSync(dir);
   } catch {
   }
-  const id = createHash3("sha256").update(path18.join(dir, path18.basename(file))).digest();
+  const id = createHash3("sha256").update(path19.join(dir, path19.basename(file))).digest();
   return process.platform === "linux" ? { path: `\0mcproc-incidents-${id.toString("hex").slice(0, 32)}` } : { host: "127.0.0.1", port: 4e4 + id.readUInt16BE(0) % 9e3 };
 }
 function tryLock(addr) {
@@ -8829,8 +9772,8 @@ async function withStore(file, fn, waitMs = LOCK_WAIT_MS2) {
   try {
     const { result, next } = await fn(readStore(file));
     const tmp = `${file}.${randomUUID()}.tmp`;
-    fs14.writeFileSync(tmp, JSON.stringify(next));
-    fs14.renameSync(tmp, file);
+    fs15.writeFileSync(tmp, JSON.stringify(next));
+    fs15.renameSync(tmp, file);
     return result;
   } finally {
     await new Promise((r) => lock.close(r));
@@ -8897,8 +9840,8 @@ async function clearLogs(fleet, names, file = storePath(fleet.manifest.path), no
         for (const f of await flushLogs(await fleet.ctx(g.host), g.apps)) {
           const key = markKey(g.host, f.app);
           const prev = s.apps[key];
-          const mark = (path22, was) => f.failed.includes(path22) ? was : {
-            path: path22,
+          const mark = (path23, was) => f.failed.includes(path23) ? was : {
+            path: path23,
             offset: 0,
             ...was?.stamp ? { stamp: was.stamp } : {}
           };
@@ -8916,15 +9859,15 @@ async function clearLogs(fleet, names, file = storePath(fleet.manifest.path), no
             const ck = countedClearKey(key);
             next.clears[ck] = (s.clears[ck] ?? 0) + 1;
           }
-          for (const [stream, path22] of [
+          for (const [stream, path23] of [
             ["out", f.proc.out_log],
             ["err", f.proc.err_log]
           ]) {
-            if (f.failed.includes(path22)) continue;
-            const fk = fileClearKey(key, stream, path22);
+            if (f.failed.includes(path23)) continue;
+            const fk = fileClearKey(key, stream, path23);
             next.clears[fk] = (s.clears[fk] ?? 0) + 1;
           }
-          const freed = (path22, bytes) => f.failed.includes(path22) ? 0 : bytes;
+          const freed = (path23, bytes) => f.failed.includes(path23) ? 0 : bytes;
           out.push({
             app: f.app,
             host: g.host,
@@ -9170,22 +10113,22 @@ async function doctor(m, hostName, spawner, hereCheck) {
 }
 
 // src/core/init.ts
-import fs16 from "fs";
-import path20 from "path";
+import fs17 from "fs";
+import path21 from "path";
 import { parse as parseYaml3 } from "yaml";
 
 // src/core/turbo.ts
-import fs15 from "fs";
-import path19 from "path";
+import fs16 from "fs";
+import path20 from "path";
 function readJson2(p) {
   try {
-    return JSON.parse(fs15.readFileSync(p, "utf8"));
+    return JSON.parse(fs16.readFileSync(p, "utf8"));
   } catch {
     return null;
   }
 }
 function readTurbo(root) {
-  const raw = readJson2(path19.join(root, "turbo.json"));
+  const raw = readJson2(path20.join(root, "turbo.json"));
   const tasks = raw?.tasks ?? raw?.pipeline;
   if (!tasks || typeof tasks !== "object" || Array.isArray(tasks)) return null;
   const names = Object.keys(tasks);
@@ -9206,14 +10149,14 @@ function isDistLib(pkg2) {
 function loadWorkspace(root, dirs) {
   const out = [];
   for (const dir of dirs) {
-    const pkg2 = readJson2(path19.join(dir, "package.json"));
+    const pkg2 = readJson2(path20.join(dir, "package.json"));
     if (!pkg2) continue;
     const deps2 = /* @__PURE__ */ new Set();
     for (const k of ["dependencies", "devDependencies", "peerDependencies"])
       for (const d of Object.keys(pkg2[k] ?? {})) deps2.add(d);
     out.push({
-      name: String(pkg2.name ?? path19.basename(dir)),
-      dir: path19.relative(root, dir) || ".",
+      name: String(pkg2.name ?? path20.basename(dir)),
+      dir: path20.relative(root, dir) || ".",
       scripts: { ...pkg2.scripts ?? {} },
       deps: [...deps2],
       distLib: isDistLib(pkg2)
@@ -9246,11 +10189,11 @@ function turboBin(pm) {
 function libsFilters(libs, globParents, all = []) {
   const folded = new Set(libs.map((l) => l.name));
   const shared = new Set(
-    all.filter((p) => p.scripts.build && !folded.has(p.name)).map((p) => path19.dirname(p.dir))
+    all.filter((p) => p.scripts.build && !folded.has(p.name)).map((p) => path20.dirname(p.dir))
   );
   const out = [];
   for (const l of libs) {
-    const parent = path19.dirname(l.dir);
+    const parent = path20.dirname(l.dir);
     const f = globParents.includes(parent) && !shared.has(parent) ? `--filter='./${parent}/*'` : `--filter=${l.name}`;
     if (!out.includes(f)) out.push(f);
   }
@@ -9277,9 +10220,9 @@ function sanitizeName(s) {
   return n || "app";
 }
 function pmFor(root) {
-  if (fs16.existsSync(path20.join(root, "yarn.lock"))) return "yarn";
-  if (fs16.existsSync(path20.join(root, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs16.existsSync(path20.join(root, "bun.lock")) || fs16.existsSync(path20.join(root, "bun.lockb")))
+  if (fs17.existsSync(path21.join(root, "yarn.lock"))) return "yarn";
+  if (fs17.existsSync(path21.join(root, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs17.existsSync(path21.join(root, "bun.lock")) || fs17.existsSync(path21.join(root, "bun.lockb")))
     return "bun run";
   return "npm run";
 }
@@ -9287,12 +10230,12 @@ function walk(dir, maxDepth, depth = 0) {
   const out = [];
   let entries;
   try {
-    entries = fs16.readdirSync(dir, { withFileTypes: true });
+    entries = fs17.readdirSync(dir, { withFileTypes: true });
   } catch {
     return out;
   }
   for (const e of entries) {
-    const p = path20.join(dir, e.name);
+    const p = path21.join(dir, e.name);
     if (e.isDirectory()) {
       if (SKIP_DIRS.has(e.name) || e.name.startsWith(".")) continue;
       if (depth < maxDepth) out.push(...walk(p, maxDepth, depth + 1));
@@ -9373,7 +10316,7 @@ function vitePort(dir, section2, config) {
   let raw;
   for (const f of config ? [config] : VITE_CONFIGS) {
     try {
-      raw = fs16.readFileSync(path20.resolve(dir, f), "utf8");
+      raw = fs17.readFileSync(path21.resolve(dir, f), "utf8");
       break;
     } catch {
     }
@@ -9397,9 +10340,9 @@ function guessPort(cmd, dir) {
   const m = /(?:\bPORT=|--port[= ]|\s-p\s)(\d{2,5})\b/.exec(cmd);
   if (m) return Number(m[1]);
   for (const f of [".env", ".env.local", ".env.development"]) {
-    const p = path20.join(dir, f);
-    if (!fs16.existsSync(p)) continue;
-    const e = /^\s*PORT=["']?(\d{2,5})/m.exec(fs16.readFileSync(p, "utf8"));
+    const p = path21.join(dir, f);
+    if (!fs17.existsSync(p)) continue;
+    const e = /^\s*PORT=["']?(\d{2,5})/m.exec(fs17.readFileSync(p, "utf8"));
     if (e) return Number(e[1]);
   }
   if (NEXT_RE.test(cmd)) return 3e3;
@@ -9410,10 +10353,10 @@ function guessPort(cmd, dir) {
     const p = vitePort(dir, section2, config);
     return p === null ? void 0 : p ?? (section2 === "server" ? 5173 : 4173);
   }
-  const src = path20.join(dir, "src");
-  if (fs16.existsSync(src)) {
+  const src = path21.join(dir, "src");
+  if (fs17.existsSync(src)) {
     for (const f of walk(src, 3).filter((x) => /\.(ts|js|mjs|cjs|tsx|jsx)$/.test(x)).slice(0, 200)) {
-      const text = fs16.readFileSync(f, "utf8");
+      const text = fs17.readFileSync(f, "utf8");
       const l = /\.listen\(\s*(\d{2,5})\b/.exec(text) ?? /\b(?:DEFAULT_)?PORT\b\s*(?::\s*number)?\s*=\s*(\d{2,5})\b/.exec(
         text
       ) ?? /\bPORT\s*\)?\s*(?:\?\?|\|\|)\s*["']?(\d{2,5})\b/.exec(text);
@@ -9436,10 +10379,10 @@ var notAwaited = (lib) => {
   return `${app}'s first build is not awaited; uncomment ${app}-build and add { app: ${app}-build, condition: completed } to its depends_on to wait for it`;
 };
 function packageCandidates(root, pkgDir, pm, turbo) {
-  const pkg2 = readJson2(path20.join(pkgDir, "package.json"));
+  const pkg2 = readJson2(path21.join(pkgDir, "package.json"));
   if (!pkg2?.scripts) return [];
-  const rel = path20.relative(root, pkgDir) || ".";
-  const appName = pkgAppName(String(pkg2.name ?? path20.basename(pkgDir)));
+  const rel = path21.relative(root, pkgDir) || ".";
+  const appName = pkgAppName(String(pkg2.name ?? path21.basename(pkgDir)));
   const prefix = rel === "." ? "" : `${appName}-`;
   const file = `${rel === "." ? "" : `${rel}/`}package.json`;
   const out = [];
@@ -9482,21 +10425,21 @@ function expandWorkspaces(root, patterns) {
   for (const pat of patterns) {
     const glob = /^(.*?)\/\*\*?$/.exec(pat);
     if (glob) {
-      const base = path20.join(root, glob[1]);
-      globParents.push(path20.relative(root, base));
+      const base = path21.join(root, glob[1]);
+      globParents.push(path21.relative(root, base));
       let names = [];
       try {
-        names = fs16.readdirSync(base);
+        names = fs17.readdirSync(base);
       } catch {
       }
       names.sort();
       for (const d of names)
-        if (fs16.existsSync(path20.join(base, d, "package.json")))
-          dirs.add(path20.join(base, d));
+        if (fs17.existsSync(path21.join(base, d, "package.json")))
+          dirs.add(path21.join(base, d));
     } else if (pat.includes("*")) {
       unsupported.push(pat);
-    } else if (fs16.existsSync(path20.join(root, pat, "package.json"))) {
-      dirs.add(path20.join(root, pat));
+    } else if (fs17.existsSync(path21.join(root, pat, "package.json"))) {
+      dirs.add(path21.join(root, pat));
     }
   }
   return { dirs: [...dirs], unsupported, globParents };
@@ -9505,7 +10448,7 @@ function libsBuilders(folded, all, globParents, pm, version) {
   const bin = turboBin(pm);
   const ui = version === 2 ? " --ui=stream" : "";
   const filters = libsFilters(folded, globParents, all).join(" ");
-  const parents = [...new Set(folded.map((p) => path20.dirname(p.dir)))].join(
+  const parents = [...new Set(folded.map((p) => path21.dirname(p.dir)))].join(
     ", "
   );
   const libs = {
@@ -9564,12 +10507,12 @@ function discover(root) {
   const candidates = [];
   const notes = [];
   const pm = pmFor(root);
-  const pkg2 = readJson2(path20.join(root, "package.json"));
+  const pkg2 = readJson2(path21.join(root, "package.json"));
   const ws = Array.isArray(pkg2?.workspaces) ? [...pkg2.workspaces] : Array.isArray(pkg2?.workspaces?.packages) ? [...pkg2.workspaces.packages] : [];
-  const pnpmWs = path20.join(root, "pnpm-workspace.yaml");
-  if (fs16.existsSync(pnpmWs)) {
+  const pnpmWs = path21.join(root, "pnpm-workspace.yaml");
+  if (fs17.existsSync(pnpmWs)) {
     try {
-      const y = parseYaml3(fs16.readFileSync(pnpmWs, "utf8"));
+      const y = parseYaml3(fs17.readFileSync(pnpmWs, "utf8"));
       if (Array.isArray(y?.packages)) ws.push(...y.packages);
     } catch {
       notes.push("pnpm-workspace.yaml could not be parsed");
@@ -9577,8 +10520,8 @@ function discover(root) {
   }
   const expanded = expandWorkspaces(root, ws);
   const turbo = readTurbo(root);
-  const turboFile = path20.join(root, "turbo.json");
-  if (!turbo && fs16.existsSync(turboFile) && readJson2(turboFile) === null)
+  const turboFile = path21.join(root, "turbo.json");
+  if (!turbo && fs17.existsSync(turboFile) && readJson2(turboFile) === null)
     notes.push(
       "turbo.json could not be parsed (comments are not read); drafted without turbo's tasks"
     );
@@ -9604,7 +10547,7 @@ function discover(root) {
   }
   candidates.push(...packageCandidates(root, root, pm));
   for (const dir of expanded.dirs) {
-    const p = liveTask ? pkgs.find((x) => x.dir === path20.relative(root, dir)) : void 0;
+    const p = liveTask ? pkgs.find((x) => x.dir === path21.relative(root, dir)) : void 0;
     candidates.push(
       ...packageCandidates(
         root,
@@ -9625,20 +10568,20 @@ function discover(root) {
       `workspace pattern "${pat}" is not expanded by init; add its packages' scripts by hand`
     );
   for (const f of walk(root, 4).filter(
-    (p) => path20.basename(p) === "project.json"
+    (p) => path21.basename(p) === "project.json"
   )) {
     const pj = readJson2(f);
     if (!pj?.targets) continue;
-    const name2 = String(pj.name ?? path20.basename(path20.dirname(f)));
+    const name2 = String(pj.name ?? path21.basename(path21.dirname(f)));
     for (const t of ["serve", "dev", "build"]) {
       if (!pj.targets[t]) continue;
       candidates.push({
         name: sanitizeName(`${name2}-${t}`),
-        source: `${path20.relative(root, f)}:${t}`,
+        source: `${path21.relative(root, f)}:${t}`,
         run: `npx nx run ${name2}:${t}${t === "build" ? " --watch" : ""}`,
         cwd: ".",
         kind: t === "build" ? "build" : "server",
-        port: t === "build" ? void 0 : guessPort("", path20.dirname(f))
+        port: t === "build" ? void 0 : guessPort("", path21.dirname(f))
       });
     }
   }
@@ -9653,7 +10596,7 @@ function discover(root) {
       kind: guessKind(t, "")
     });
   }
-  const eco = readJson2(path20.join(root, "ecosystem.json"));
+  const eco = readJson2(path21.join(root, "ecosystem.json"));
   if (Array.isArray(eco?.apps)) {
     for (const a of eco.apps) {
       if (!a?.name) continue;
@@ -9674,14 +10617,14 @@ function discover(root) {
     "ecosystem.config.cjs",
     "ecosystem.config.mjs"
   ]) {
-    if (fs16.existsSync(path20.join(root, f)))
+    if (fs17.existsSync(path21.join(root, f)))
       notes.push(
         `${f} found: JavaScript ecosystem files are not executed by init; port its apps by hand`
       );
   }
-  const procfile = path20.join(root, "Procfile");
-  if (fs16.existsSync(procfile)) {
-    for (const line of fs16.readFileSync(procfile, "utf8").split("\n")) {
+  const procfile = path21.join(root, "Procfile");
+  if (fs17.existsSync(procfile)) {
+    for (const line of fs17.readFileSync(procfile, "utf8").split("\n")) {
       const m = /^\s*([A-Za-z0-9_-]+):\s*(.+)$/.exec(line);
       if (m) {
         const kind = guessKind(m[1], m[2]);
@@ -9815,20 +10758,20 @@ function localReadonly(text) {
   }
 }
 function initProject(rootIn, opts = {}) {
-  const root = path20.resolve(rootIn);
-  if (!fs16.existsSync(root))
+  const root = path21.resolve(rootIn);
+  if (!fs17.existsSync(root))
     throw new McprocError(
       "MANIFEST_NOT_FOUND",
       `Project directory does not exist: ${root}`
     );
-  const dir = path20.join(root, ".mcproc");
-  const file = path20.join(root, MANIFEST_REL);
-  if (fs16.existsSync(file) && !opts.force) {
+  const dir = path21.join(root, ".mcproc");
+  const file = path21.join(root, MANIFEST_REL);
+  if (fs17.existsSync(file) && !opts.force) {
     throw new McprocError("ALREADY_EXISTS", `${file} already exists`, {
       hint: "Overwrite the draft with force (README and .gitignore are kept), or keep it and adopt the running apps' ports into it."
     });
   }
-  if (fs16.existsSync(file) && localReadonly(fs16.readFileSync(file, "utf8"))) {
+  if (fs17.existsSync(file) && localReadonly(fs17.readFileSync(file, "utf8"))) {
     throw new McprocError(
       "READONLY_HOST",
       `${file} declares the local host readonly; init does not replace it, not even with force`,
@@ -9837,20 +10780,20 @@ function initProject(rootIn, opts = {}) {
       }
     );
   }
-  fs16.mkdirSync(dir, { recursive: true });
+  fs17.mkdirSync(dir, { recursive: true });
   const created = [];
-  const gi = path20.join(dir, ".gitignore");
-  if (!fs16.existsSync(gi) || fs16.readFileSync(gi, "utf8").trim() !== "*") {
-    fs16.writeFileSync(gi, "*\n");
+  const gi = path21.join(dir, ".gitignore");
+  if (!fs17.existsSync(gi) || fs17.readFileSync(gi, "utf8").trim() !== "*") {
+    fs17.writeFileSync(gi, "*\n");
     created.push(gi);
   }
-  const readme = path20.join(dir, "README.md");
-  if (!fs16.existsSync(readme)) {
-    fs16.writeFileSync(readme, README_TEMPLATE);
+  const readme = path21.join(dir, "README.md");
+  if (!fs17.existsSync(readme)) {
+    fs17.writeFileSync(readme, README_TEMPLATE);
     created.push(readme);
   }
   const d = discover(root);
-  fs16.writeFileSync(file, renderDraft(root, defaultProject(root), d));
+  fs17.writeFileSync(file, renderDraft(root, defaultProject(root), d));
   created.push(file);
   const by_source = {};
   for (const c of d.candidates) {
@@ -9872,7 +10815,7 @@ function initProject(rootIn, opts = {}) {
 }
 
 // src/core/adopt.ts
-import fs17 from "fs";
+import fs18 from "fs";
 import { isMap, isScalar, isSeq, parse, parseDocument } from "yaml";
 var EPHEMERAL_FROM = 32768;
 function planAdoption(rows, m) {
@@ -10155,7 +11098,7 @@ async function adoptPorts(fleet) {
         hint: "Edit the manifest by hand, or remove hosts.local.readonly first."
       }
     );
-  const before = fs17.readFileSync(m.path, "utf8");
+  const before = fs18.readFileSync(m.path, "utf8");
   const current = parseManifest(before, m.root, m.path, loadOverride(m.root));
   const { rows, errors } = await listFleet(fleet, fleet.select(["all"]), {
     cpu: "none",
@@ -10185,13 +11128,13 @@ async function adoptPorts(fleet) {
       }
     );
   }
-  if (fs17.readFileSync(m.path, "utf8") !== before)
+  if (fs18.readFileSync(m.path, "utf8") !== before)
     throw new McprocError(
       "ALREADY_EXISTS",
       `${m.path} changed while the ports were being probed; nothing written`,
       { hint: "Run the adoption again." }
     );
-  fs17.writeFileSync(m.path, splice.text);
+  fs18.writeFileSync(m.path, splice.text);
   return {
     path: m.path,
     written: true,
@@ -10648,6 +11591,28 @@ function registerReadTools(server, deps2) {
       };
     })
   );
+  server.registerTool(
+    "stacks",
+    {
+      title: "Stacks",
+      description: "Every mcproc stack on this host, not only this project: each checkout any mcproc call has seen or found in the local pm2 daemon, with its root, hosts, apps online/total, errors, memory, CPU and listening ports, plus pm2 processes no manifest knows. Use it to see what else runs here (another checkout holding a port or memory); act on another stack by passing its root as `project` to the other tools.",
+      inputSchema: {
+        all: z4.boolean().optional().describe("also the recorded checkouts with nothing in pm2")
+      },
+      annotations: RO
+    },
+    (args) => runTool(async () => {
+      const deps22 = defaultCollectorDeps(deps2.spawner);
+      if (deps2.hereCheck) deps22.hereCheck = deps2.hereCheck;
+      const v = await new StacksCollector(deps22).collect({
+        all: Boolean(args.all)
+      });
+      return {
+        text: renderStacks(v.answer),
+        data: v.answer
+      };
+    })
+  );
   server.registerTool(
     "incidents",
     {
@@ -11181,7 +12146,8 @@ function initialState(p) {
     incidentsCleared: null,
     incidentsErrors: [],
     incidentsTaken: {},
-    hideTaken: false
+    hideTaken: false,
+    toStacks: p.toStacks ?? false
   };
 }
 function visibleIncidents(s) {
@@ -11405,181 +12371,64 @@ function keyIntent(key, s, now = Date.now()) {
       return confirms("clear") ? { kind: "clear", apps } : {
         kind: "action",
         action: { type: "arm", at: now, what: "clear", apps }
-      };
-    }
-    case "S-r": {
-      const apps = s.rows.map((r) => r.app);
-      if (s.busy || apps.length === 0) return null;
-      return confirms("reload") ? { kind: "reload-all" } : {
-        kind: "action",
-        action: { type: "arm", at: now, what: "reload", apps }
-      };
-    }
-    case "q":
-    case "C-c":
-    case "escape":
-      return { kind: "quit" };
-    default:
-      return null;
-  }
-}
-function selectedRow(s) {
-  return s.rows[s.selected] ?? null;
-}
-function visibleLogs(s) {
-  const all = s.logs[selectedApp(s) ?? ""] ?? [];
-  const lines = s.stream === "both" ? all : all.filter((l) => l.stream === s.stream);
-  return s.stream === "both" ? sortByStamp(lines) : lines;
-}
-function visibleFlat(s) {
-  const hostOf = new Map(s.rows.map((r) => [r.app, r.host]));
-  const entries = Object.entries(s.logs).filter(
-    ([, lines]) => lines.length > 0
-  );
-  const hosts = [...new Set(entries.map(([app]) => hostOf.get(app)))];
-  const key = `${s.stream}|${hosts.join(",")}`;
-  if (flatMemo && flatMemo.logs === s.logs && flatMemo.key === key)
-    return flatMemo.out;
-  const all = entries.flatMap(
-    ([app, lines]) => lines.map((l) => flatLineOf(app, l))
-  );
-  const shown = s.stream === "both" ? all : all.filter((l) => l.stream === s.stream);
-  const byArrival = shown.sort((a, b) => a.seq - b.seq);
-  const out = hosts.length <= 1 ? sortByStamp(byArrival) : byArrival;
-  flatMemo = { logs: s.logs, key, out };
-  return out;
-}
-var flatLines = /* @__PURE__ */ new WeakMap();
-function flatLineOf(app, l) {
-  let f = flatLines.get(l);
-  if (!f) {
-    f = { app, stream: l.stream, text: l.text, seq: l.seq };
-    flatLines.set(l, f);
-  }
-  return f;
-}
-var flatMemo = null;
-
-// src/monit/screentext.ts
-import { charWidth, chars } from "@pm2/blessed/lib/unicode.js";
-var segmenter = new Intl.Segmenter("en", { granularity: "grapheme" });
-var EMOJI_PRESENTATION = new RegExp("\\p{Emoji_Presentation}", "u");
-var PICTOGRAPH = new RegExp("\\p{Extended_Pictographic}", "u");
-var REGIONAL = new RegExp("\\p{Regional_Indicator}", "u");
-var KEYCAP = /^[0-9#*]\uFE0F?\u20E3$/;
-var INVISIBLE = /[\p{Cc}\p{Cf}]/u;
-var LINE_BREAK = /\r\n|[\n\v\f\u0085\u2028\u2029]/g;
-var MARK2 = new RegExp("\\p{M}", "u");
-var SPACING_MARK = new RegExp("\\p{Mc}", "u");
-var BLESSED_WIDE = new RegExp(chars.wide.source);
-var NARROW = {
-  "\u2705": "\u2714",
-  "\u274C": "\u2716",
-  "\u274E": "\u2716",
-  "\u2757": "!",
-  "\u2755": "!",
-  "\u2753": "?",
-  "\u2754": "?"
-};
-var TAB = 8;
-function displayWidth(s) {
-  let w = 0;
-  for (const ch of s.includes("\x1B") ? s.replace(SGR_RE, "") : s)
-    w += charWidth(ch.codePointAt(0)) === 2 ? 2 : 1;
-  return w;
-}
-function columns(s) {
-  let w = 0;
-  for (const ch of s) w += charWidth(ch.codePointAt(0));
-  return w;
-}
-function keepMark(ch, cp) {
-  return cp <= 65535 && charWidth(cp) === (SPACING_MARK.test(ch) ? 1 : 0);
-}
-function cluster(c) {
-  if (c === "	") return c;
-  const first = String.fromCodePoint(c.codePointAt(0));
-  if (REGIONAL.test(first))
-    return [...c].filter((ch) => REGIONAL.test(ch)).map((ch) => String.fromCharCode(ch.codePointAt(0) - 127462 + 65)).join("");
-  if (KEYCAP.test(c)) return c[0];
-  if (PICTOGRAPH.test(first) || EMOJI_PRESENTATION.test(first)) {
-    if (NARROW[first]) return NARROW[first];
-    return !EMOJI_PRESENTATION.test(first) && first.length === 1 ? first : "?";
-  }
-  let out = "";
-  for (const ch of c) {
-    if (INVISIBLE.test(ch)) continue;
-    const cp = ch.codePointAt(0);
-    if (MARK2.test(ch)) {
-      if (keepMark(ch, cp)) out += ch;
-      continue;
-    }
-    if (cp > 65535 || cp >= 55296 && cp <= 57343) {
-      out += "?";
-      continue;
-    }
-    out += charWidth(cp) === 2 === BLESSED_WIDE.test(ch) ? ch : "?";
-  }
-  return out;
-}
-function blessedSgr(code) {
-  if (!code.includes(":")) return code;
-  const groups = code.slice(2, -1).split(";").flatMap((g) => {
-    if (!g.includes(":")) return [g];
-    const [kind, mode, ...rest] = g.split(":");
-    if (kind === "4") return ["4"];
-    if (!["38", "48", "58"].includes(kind)) return [];
-    if (mode === "5" && rest[0]) return [`${kind};5;${rest[0]}`];
-    if (mode === "2" && rest.length >= 3)
-      return [`${kind};2;${rest.slice(-3).join(";")}`];
-    return [];
-  });
-  return groups.length ? `\x1B[${groups.join(";")}m` : "";
-}
-var SGR_SPLIT = /(\x1b\[[0-9;:]*m)/;
-var visible = (t) => t.replace(SGR_RE, "");
-function screenText(input, opts = {}) {
-  const parts = (opts.colors ? keepSgr(input) : stripAnsi(input)).replace(/\r\n/g, "\n").split("\r");
-  let last = parts.length - 1;
-  while (last > 0 && visible(parts[last]) === "") last--;
-  const carried = parts.slice(0, last).flatMap((p) => p.match(SGR_RE) ?? []).join("");
-  let out = "";
-  let col = 0;
-  for (const piece of (carried + parts[last]).split(SGR_SPLIT)) {
-    if (SGR_SPLIT.test(piece) && piece.startsWith("\x1B")) {
-      out += blessedSgr(piece);
-      continue;
-    }
-    for (const { segment } of segmenter.segment(
-      piece.replace(LINE_BREAK, " ").normalize("NFC")
-    )) {
-      const c = cluster(segment);
-      if (c === "	") {
-        const n = TAB - col % TAB;
-        out += " ".repeat(n);
-        col += n;
-        continue;
-      }
-      out += c;
-      col += columns(c);
+      };
+    }
+    case "S-r": {
+      const apps = s.rows.map((r) => r.app);
+      if (s.busy || apps.length === 0) return null;
+      return confirms("reload") ? { kind: "reload-all" } : {
+        kind: "action",
+        action: { type: "arm", at: now, what: "reload", apps }
+      };
     }
+    case "q":
+    case "C-c":
+      return { kind: "quit" };
+    case "escape":
+      return s.toStacks ? { kind: "back" } : { kind: "quit" };
+    default:
+      return null;
   }
+}
+function selectedRow(s) {
+  return s.rows[s.selected] ?? null;
+}
+function visibleLogs(s) {
+  const all = s.logs[selectedApp(s) ?? ""] ?? [];
+  const lines = s.stream === "both" ? all : all.filter((l) => l.stream === s.stream);
+  return s.stream === "both" ? sortByStamp(lines) : lines;
+}
+function visibleFlat(s) {
+  const hostOf = new Map(s.rows.map((r) => [r.app, r.host]));
+  const entries = Object.entries(s.logs).filter(
+    ([, lines]) => lines.length > 0
+  );
+  const hosts = [...new Set(entries.map(([app]) => hostOf.get(app)))];
+  const key = `${s.stream}|${hosts.join(",")}`;
+  if (flatMemo && flatMemo.logs === s.logs && flatMemo.key === key)
+    return flatMemo.out;
+  const all = entries.flatMap(
+    ([app, lines]) => lines.map((l) => flatLineOf(app, l))
+  );
+  const shown = s.stream === "both" ? all : all.filter((l) => l.stream === s.stream);
+  const byArrival = shown.sort((a, b) => a.seq - b.seq);
+  const out = hosts.length <= 1 ? sortByStamp(byArrival) : byArrival;
+  flatMemo = { logs: s.logs, key, out };
   return out;
 }
-function cutWidth(s, width) {
-  if (displayWidth(s) <= width) return s;
-  let out = "";
-  let w = 0;
-  for (const ch of s) {
-    const cw = displayWidth(ch);
-    if (w + cw > width - 1) break;
-    out += ch;
-    w += cw;
+var flatLines = /* @__PURE__ */ new WeakMap();
+function flatLineOf(app, l) {
+  let f = flatLines.get(l);
+  if (!f) {
+    f = { app, stream: l.stream, text: l.text, seq: l.seq };
+    flatLines.set(l, f);
   }
-  return `${out}\u2026`;
+  return f;
 }
+var flatMemo = null;
 
 // src/monit/frame.ts
+var stacksKey = (s) => s.toStacks ? "esc stacks  " : "";
 function pane(entries, scroll, shift, logH, rowsOf) {
   let filled = 0;
   let k = 0;
@@ -11814,7 +12663,7 @@ function renderFrame(s, size) {
       spec2.rowsOf
     );
     const empty = !s.incidentsPolled ? "reading incidents\u2026" : s.incidents.length ? "every incident here is taken (t shows them)" : `no incidents in the last ${DEFAULT_SINCE_MIN} min`;
-    const keys2 = `\u2191\u2193 scroll  i back  f flat  t ${s.hideTaken ? "show" : "hide"} taken  c clear  R reload all  h host  q quit`;
+    const keys2 = `${stacksKey(s)}\u2191\u2193 scroll  i back  f flat  t ${s.hideTaken ? "show" : "hide"} taken  c clear  R reload all  h host  q quit`;
     return {
       header,
       table: [],
@@ -11837,7 +12686,7 @@ function renderFrame(s, size) {
       spec2.logH,
       spec2.rowsOf
     );
-    const keys2 = "\u2191\u2193 scroll  c clear  R reload all  f dashboard  o/e/b logs  i incidents  h host  q quit";
+    const keys2 = `${stacksKey(s)}\u2191\u2193 scroll  c clear  R reload all  f dashboard  o/e/b logs  i incidents  h host  q quit`;
     return {
       header,
       table: [],
@@ -11849,32 +12698,37 @@ function renderFrame(s, size) {
     };
   }
   const multi = new Set(s.rows.map((r2) => r2.host)).size > 1;
-  const tableLines = table([
+  const o = multi ? 1 : 0;
+  const tableLines = table(
     [
-      "",
-      "APP",
-      ...multi ? ["HOST"] : [],
-      "STATUS",
-      "UP",
-      "MEM",
-      "CPU",
-      "PORTS",
-      "URL",
-      "RUNTIME"
+      [
+        "",
+        "APP",
+        ...multi ? ["HOST"] : [],
+        "STATUS",
+        "UP",
+        "MEM",
+        "CPU",
+        "PORTS",
+        "URL",
+        "RUNTIME"
+      ],
+      ...s.rows.map((r2, i) => [
+        i === s.selected ? "\u25B6" : " ",
+        r2.app,
+        ...multi ? [r2.host] : [],
+        r2.status,
+        fmtUptime(r2.uptime_ms),
+        r2.memory ? fmtBytes(r2.memory) : "-",
+        r2.status === "online" ? fmtCpu(r2.cpu) : "-",
+        screenText(fmtPorts(r2.ports)),
+        screenText(fmtUrl(r2)),
+        r2.runtime ? screenText(r2.runtime) : "-"
+      ])
     ],
-    ...s.rows.map((r2, i) => [
-      i === s.selected ? "\u25B6" : " ",
-      r2.app,
-      ...multi ? [r2.host] : [],
-      r2.status,
-      fmtUptime(r2.uptime_ms),
-      r2.memory ? fmtBytes(r2.memory) : "-",
-      r2.status === "online" ? fmtCpu(r2.cpu) : "-",
-      cutWidth(screenText(fmtPorts(r2.ports)), 22),
-      cutWidth(screenText(fmtUrl(r2)), 36),
-      r2.runtime ? cutWidth(screenText(r2.runtime), 40) : "-"
-    ])
-  ]).split("\n").map((l) => cutWidth(l.replace(/^(.)\s\s/, "$1"), w));
+    // +2: the marker column's gutter is dropped below, so the table may use those two columns
+    { width: w + 2, flex: [6 + o, 7 + o, 8 + o], mode: "fit" }
+  ).split("\n").map((l) => cutWidth(l.replace(/^(.)\s\s/, "$1"), w));
   const spec = paneSpec(s, size);
   const p = pane(
     spec.entries,
@@ -11906,7 +12760,7 @@ function renderFrame(s, size) {
       w
     )
   ] : ["no app selected"];
-  const keys = "j/k app  \u2191\u2193 scroll  r restart  R reload all  s start  x stop  c clear  o/e/b logs  f flat  i incidents  h host  q quit";
+  const keys = `${stacksKey(s)}j/k app  \u2191\u2193 scroll  r restart  R reload all  s start  x stop  c clear  o/e/b logs  f flat  i incidents  h host  q quit`;
   const footer = cutWidth(right ? `${right}  \u2502 ${keys}` : keys, w);
   return {
     header,
@@ -12011,31 +12865,31 @@ async function monitOnce(opts, deps2 = {}) {
 }
 
 // src/cli/install.ts
-import fs18 from "fs";
-import os6 from "os";
-import path21 from "path";
+import fs19 from "fs";
+import os9 from "os";
+import path22 from "path";
 var LAUNCHER_MARK = "# written by mcproc install";
 function rcFor(home, shell) {
-  const name2 = path21.basename(shell || "");
-  return path21.join(
+  const name2 = path22.basename(shell || "");
+  return path22.join(
     home,
     name2 === "zsh" ? ".zshrc" : name2 === "bash" ? ".bashrc" : ".profile"
   );
 }
 function installShortcut(o = {}) {
-  const home = o.home ?? os6.homedir();
-  const binDir = path21.resolve(o.binDir ?? path21.join(home, ".local", "bin"));
-  const cli = path21.resolve(
-    o.cliPath ?? path21.join(findPackageRoot(), "dist", "cli.js")
+  const home = o.home ?? os9.homedir();
+  const binDir = path22.resolve(o.binDir ?? path22.join(home, ".local", "bin"));
+  const cli = path22.resolve(
+    o.cliPath ?? path22.join(findPackageRoot(), "dist", "cli.js")
   );
-  const launcher = path21.join(binDir, "mcproc");
+  const launcher = path22.join(binDir, "mcproc");
   const pathEnv = o.pathEnv ?? process.env.PATH ?? "";
-  const onPath = pathEnv.split(":").some((p) => p && path21.resolve(p.replace(/^~(?=\/|$)/, home)) === binDir);
+  const onPath = pathEnv.split(":").some((p) => p && path22.resolve(p.replace(/^~(?=\/|$)/, home)) === binDir);
   const next = [];
   if (o.uninstall) {
-    const exists = fs18.existsSync(launcher);
-    const ours = exists && fs18.readFileSync(launcher, "utf8").includes(LAUNCHER_MARK);
-    if (ours) fs18.unlinkSync(launcher);
+    const exists = fs19.existsSync(launcher);
+    const ours = exists && fs19.readFileSync(launcher, "utf8").includes(LAUNCHER_MARK);
+    if (ours) fs19.unlinkSync(launcher);
     else if (exists)
       next.push(`${launcher} was not written by mcproc install; left in place`);
     else next.push(`nothing at ${launcher}`);
@@ -12051,43 +12905,43 @@ function installShortcut(o = {}) {
       next
     };
   }
-  fs18.mkdirSync(binDir, { recursive: true });
+  fs19.mkdirSync(binDir, { recursive: true });
   let existing = null;
   try {
-    existing = fs18.lstatSync(launcher);
+    existing = fs19.lstatSync(launcher);
   } catch {
   }
   if (existing?.isSymbolicLink()) {
     throw new McprocError(
       "BAD_ARGUMENT",
-      `${launcher} is a symlink (to ${fs18.readlinkSync(launcher)}); refusing to write through it`,
+      `${launcher} is a symlink (to ${fs19.readlinkSync(launcher)}); refusing to write through it`,
       { hint: "Remove it yourself, or pass another --bin-dir." }
     );
   }
-  if (existing && !fs18.readFileSync(launcher, "utf8").includes(LAUNCHER_MARK)) {
+  if (existing && !fs19.readFileSync(launcher, "utf8").includes(LAUNCHER_MARK)) {
     throw new McprocError(
       "BAD_ARGUMENT",
       `${launcher} exists and was not written by mcproc install; refusing to overwrite it`,
       { hint: "Remove it yourself, or pass another --bin-dir." }
     );
   }
-  fs18.writeFileSync(
+  fs19.writeFileSync(
     launcher,
     `#!/bin/sh
-${LAUNCHER_MARK}: runs the mcproc at ${path21.dirname(path21.dirname(cli))}
+${LAUNCHER_MARK}: runs the mcproc at ${path22.dirname(path22.dirname(cli))}
 exec node ${shq(cli)} "$@"
 `
   );
-  fs18.chmodSync(launcher, 493);
+  fs19.chmodSync(launcher, 493);
   let rcFile = null;
   let rcUpdated = false;
   if (!onPath) {
     rcFile = rcFor(home, o.shell ?? process.env.SHELL ?? "");
-    const shown = binDir.startsWith(home + path21.sep) ? `$HOME/${path21.relative(home, binDir)}` : binDir;
+    const shown = binDir.startsWith(home + path22.sep) ? `$HOME/${path22.relative(home, binDir)}` : binDir;
     const line = `export PATH="${shown}:$PATH"`;
-    const current = fs18.existsSync(rcFile) ? fs18.readFileSync(rcFile, "utf8") : "";
+    const current = fs19.existsSync(rcFile) ? fs19.readFileSync(rcFile, "utf8") : "";
     if (!current.includes(line)) {
-      fs18.appendFileSync(
+      fs19.appendFileSync(
         rcFile,
         `${current === "" || current.endsWith("\n") ? "" : "\n"}
 # mcproc install: the shortcut lives in ${shown}
@@ -12195,6 +13049,7 @@ var MonitLoop = class {
   inc = freshView();
   /** One refresh of every host of the view (or of `hosts`); a host whose refresh of this generation is still in flight shares it. */
   refresh(hosts) {
+    if (this.closed) return Promise.resolve();
     this.readCleared();
     this.syncWatches();
     const gen = this.gen;
@@ -12304,6 +13159,7 @@ var MonitLoop = class {
     const probed = this.losses;
     try {
       const ctx = await this.fleet.ctx(g.host);
+      if (gen !== this.gen) return;
       const snap = await this.deps.snapshot(ctx, {
         cpu: "none",
         prev: this.prev.get(g.host),
@@ -12513,6 +13369,8 @@ var MonitLoop = class {
   /** The screen is going away: no follower wakes it any more, and a running reload stops waiting for dependencies. */
   close() {
     this.closed = true;
+    this.gen++;
+    this.switchSeq++;
     this.reloading?.abort();
     for (const q of this.wakes.values()) {
       if (q.timer) clearTimeout(q.timer);
@@ -12666,10 +13524,10 @@ var MonitLoop = class {
       this.names.map((a) => markKey(this.fleet.hostOf(a), a))
     );
     const st = this.inc;
-    const add2 = (key, stream, path22) => {
+    const add2 = (key, stream, path23) => {
       const by = st.pending[key] ?? {};
       const paths = by[stream] ?? /* @__PURE__ */ new Set();
-      paths.add(path22);
+      paths.add(path23);
       by[stream] = paths;
       st.pending[key] = by;
     };
@@ -12812,9 +13670,11 @@ async function runMonit(opts) {
     project: manifest.project,
     host: viewLabel(fleet.requested),
     hosts: views.map(viewLabel),
-    apps: appInfos(manifest)
+    apps: appInfos(manifest),
+    toStacks: Boolean(opts.back)
   });
-  const screen = blessed.screen({
+  const own2 = !opts.screen;
+  const screen = opts.screen ?? blessed.screen({
     smartCSR: true,
     title: "mcproc monit",
     fullUnicode: true
@@ -12833,7 +13693,7 @@ async function runMonit(opts) {
   const detailsTitle = box({ bottom: 7, height: 1 });
   const detailsBox = box({ bottom: 1, height: 6 });
   const footer = box({ bottom: 0, height: 1 });
-  for (const b of [
+  const boxes = [
     header,
     appsTitle,
     tableBox,
@@ -12842,8 +13702,8 @@ async function runMonit(opts) {
     detailsTitle,
     detailsBox,
     footer
-  ])
-    screen.append(b);
+  ];
+  for (const b of boxes) screen.append(b);
   const appColor = new Map(
     Object.keys(manifest.apps).map((a, i) => [a, colorFor(i)])
   );
@@ -12856,7 +13716,9 @@ async function runMonit(opts) {
     width: screen.width,
     height: screen.height
   });
+  let left = false;
   const show = (f) => {
+    if (left) return;
     const { width: w, height: h } = size();
     header.setContent(f.header);
     footer.setContent(f.footer);
@@ -12905,44 +13767,511 @@ async function runMonit(opts) {
     const timer = setInterval(() => {
       void loop.refresh();
     }, opts.intervalMs);
-    const quit = () => {
+    const leave = (why) => {
+      left = true;
       clearInterval(timer);
       loop.close();
+      screen.removeListener("keypress", onKey);
+      screen.removeListener("resize", paint);
+      if (own2) screen.destroy();
+      else for (const b of boxes) b.detach();
+      resolve(why);
+    };
+    const onKey = (_ch, key) => {
+      const intent = keyIntent(key.full ?? key.name ?? "", state);
+      if (state.armedAt !== null && !(intent?.kind === "action" && intent.action.type === "arm"))
+        dispatch({ type: "arm", at: null });
+      if (!intent) return;
+      if (intent.kind === "quit") return leave("quit");
+      if (intent.kind === "back") return leave("back");
+      if (intent.kind === "action") {
+        if (intent.action.type === "arm" && intent.action.at !== null) {
+          const { at, what } = intent.action;
+          setTimeout(() => {
+            if (state.armedAt === at && state.armed === what)
+              dispatch({ type: "arm", at: null });
+          }, CONFIRM_MS + 50).unref();
+        }
+        if (intent.action.type === "select")
+          loop.dispatchSelect(intent.action.delta);
+        else {
+          dispatch(intent.action);
+          if (intent.action.type === "view") void loop.refresh();
+        }
+        return;
+      }
+      if (intent.kind === "host-next") return void loop.nextView();
+      if (intent.kind === "clear") return void loop.runClear(intent.apps);
+      if (intent.kind === "reload-all") return void loop.reloadAll();
+      void loop.runCommand(intent.cmd, intent.app);
+    };
+    screen.on("keypress", onKey);
+    screen.on("resize", paint);
+    void loop.refresh().then(paint);
+  });
+}
+
+// src/monit/stacks-tui.ts
+import blessed2 from "@pm2/blessed";
+
+// src/core/stacks/stop.ts
+async function stopStack(m, connector = defaultConnector()) {
+  const out = { stopped: [], readonly: [], failed: [] };
+  try {
+    const fleet = new Fleet(m, void 0, connector);
+    const ro = /* @__PURE__ */ new Map();
+    const names = fleet.select(["all"]).filter((a) => {
+      const h = fleet.hostOf(a);
+      if (!pickHost(m, h).readonly) return true;
+      ro.set(h, [...ro.get(h) ?? [], a]);
+      return false;
+    });
+    out.readonly = [...ro].map(([host, apps]) => ({ host, apps }));
+    const mine = await ownApps(m, fleet, names, out);
+    if (mine.length === 0) return out;
+    for (const r of await actOn(fleet, mine, "stop"))
+      if (r.error)
+        out.failed.push({ host: r.host, message: `${r.app}: ${r.error}` });
+      else out.stopped.push(r.app);
+  } catch (e) {
+    out.failed.push({ host: "-", message: describeError(e) });
+  }
+  return out;
+}
+async function ownApps(m, fleet, names, out) {
+  const keep = [];
+  for (const g of fleet.groups(names)) {
+    let procs;
+    let host;
+    try {
+      const ctx = await fleet.ctx(g.host);
+      host = ctx.host;
+      procs = await ctx.pm2.jlist();
+    } catch (e) {
+      for (const a of g.apps)
+        out.failed.push({ host: g.host, message: `${a}: ${describeError(e)}` });
+      continue;
+    }
+    for (const a of g.apps) {
+      const p = findProcess(procs, m.project, a);
+      const own2 = appCwd(host, m.apps[a]);
+      if (p?.cwd && p.cwd !== own2)
+        out.failed.push({
+          host: g.host,
+          message: `${a}: runs from another checkout (${p.cwd}), left alone`
+        });
+      else keep.push(a);
+    }
+  }
+  return names.filter((a) => keep.includes(a));
+}
+
+// src/monit/stacks-state.ts
+var orphanKey = (o) => `orphan:${o.endpoint}:${o.namespace}`;
+function overviewRows(s) {
+  if (!s.view) return [];
+  return [
+    ...s.view.stacks.map((stack) => ({
+      kind: "stack",
+      key: stack.root,
+      stack
+    })),
+    ...s.view.answer.orphans.map((orphan) => ({
+      kind: "orphan",
+      key: orphanKey(orphan),
+      orphan
+    }))
+  ];
+}
+function selectedOverviewRow(s) {
+  return overviewRows(s)[s.index] ?? null;
+}
+function initialOverview(opts) {
+  return {
+    view: null,
+    selected: opts.selected ?? null,
+    index: 0,
+    all: false,
+    armedAt: null,
+    notice: null,
+    error: null,
+    busy: false,
+    updatedAt: null
+  };
+}
+var running2 = (st) => st.rows.filter(
+  (r) => r.pm_id !== null && r.status !== "stopped" && r.status !== "done"
+).length;
+function stopPrompt(st) {
+  const n = running2(st);
+  return `press x again to stop ${n} app${n === 1 ? "" : "s"} of ${st.project}`;
+}
+var unloaded = (st) => `${st.project}: the manifest did not load (${st.manifest_error?.code})`;
+function reduceOverview(s, a) {
+  switch (a.type) {
+    case "view": {
+      const next = { ...s, view: a.view, updatedAt: a.at, error: null };
+      const rows = overviewRows(next);
+      const found = rows.findIndex((r) => r.key === s.selected);
+      const index = found >= 0 ? found : Math.min(s.index, Math.max(0, rows.length - 1));
+      const selected = rows[index]?.key ?? null;
+      const moved = s.armedAt !== null && selected !== s.selected;
+      return {
+        ...next,
+        index,
+        selected,
+        ...moved ? { armedAt: null, notice: null } : {}
+      };
+    }
+    case "select": {
+      const rows = overviewRows(s);
+      if (rows.length === 0) return s;
+      const index = Math.max(0, Math.min(rows.length - 1, s.index + a.delta));
+      return { ...s, index, selected: rows[index].key, armedAt: null };
+    }
+    case "arm": {
+      const r = selectedOverviewRow(s);
+      if (a.at === null)
+        return {
+          ...s,
+          armedAt: null,
+          notice: s.armedAt !== null ? null : s.notice
+        };
+      return {
+        ...s,
+        armedAt: a.at,
+        notice: r?.kind === "stack" ? stopPrompt(r.stack) : s.notice
+      };
+    }
+    case "toggle-all":
+      return { ...s, all: !s.all };
+    case "notice":
+      return { ...s, notice: a.message, armedAt: null };
+    case "error":
+      return { ...s, error: a.message };
+    case "busy":
+      return { ...s, busy: a.busy };
+  }
+}
+function sharedSlug(st, what) {
+  const n = st.rivals.length + 1;
+  return `${st.project}: ${n} checkouts share this slug on one pm2, so ${what === "open" ? "its monit" : "a stop"} could reach another one's processes; give each checkout its own project slug`;
+}
+function overviewKey(key, s, now = Date.now()) {
+  const r = selectedOverviewRow(s);
+  const notice = (message) => ({
+    kind: "action",
+    action: { type: "notice", message }
+  });
+  switch (key) {
+    case "up":
+    case "k":
+      return { kind: "action", action: { type: "select", delta: -1 } };
+    case "down":
+    case "j":
+      return { kind: "action", action: { type: "select", delta: 1 } };
+    case "enter":
+    case "return": {
+      if (!r) return null;
+      if (r.kind === "orphan")
+        return notice("not an mcproc stack: no manifest to open");
+      if (r.stack.manifest_error) return notice(unloaded(r.stack));
+      if (r.stack.rivals?.length) return notice(sharedSlug(r.stack, "open"));
+      if (!r.stack.hosts.some((h) => h.reachable)) {
+        const why = r.stack.hosts.find((h) => h.error);
+        return notice(
+          `${r.stack.project}: no host of this stack answers${why ? ` (${why.name}: ${why.error})` : ""}`
+        );
+      }
+      return { kind: "open", root: r.stack.root };
+    }
+    case "x": {
+      if (!r || s.busy) return null;
+      if (r.kind === "orphan") return notice("not an mcproc stack: read-only");
+      if (r.stack.manifest_error) return notice(unloaded(r.stack));
+      if (r.stack.rivals?.length) return notice(sharedSlug(r.stack, "stop"));
+      if (s.armedAt !== null && now - s.armedAt <= CONFIRM_MS)
+        return { kind: "stop", root: r.stack.root };
+      return { kind: "action", action: { type: "arm", at: now } };
+    }
+    case "a":
+      return { kind: "action", action: { type: "toggle-all" } };
+    case "q":
+    case "C-c":
+    case "escape":
+      return { kind: "quit" };
+    default:
+      return null;
+  }
+}
+
+// src/monit/stacks-frame.ts
+var KEYS = (all) => `j/k stack  enter open  x stop stack  a ${all ? "running only" : "all known"}  q quit`;
+var CHROME = 4;
+var MIN_APPS = 4;
+function stackLines(st, width) {
+  const e = st.manifest_error;
+  const lines = e ? [`${e.code}: ${e.message}`, ...e.hint ? [e.hint] : []] : table(
+    [
+      ["APP", "HOST", "STATUS", "UP", "MEM", "CPU", "PORTS"],
+      ...st.rows.map((r) => [
+        r.app,
+        r.host,
+        r.status,
+        fmtUptime(r.uptime_ms),
+        r.memory ? fmtBytes(r.memory) : "-",
+        r.status === "online" ? fmtCpu(r.cpu) : "-",
+        fmtPorts(r.ports)
+      ])
+    ].map((r) => r.map((c) => screenText(c))),
+    { width, flex: [6], mode: "fit" }
+  ).split("\n");
+  for (const n of st.notes) lines.push(n);
+  for (const h of st.hosts) if (h.error) lines.push(`${h.name}: ${h.error}`);
+  return lines;
+}
+function renderOverview(s, size) {
+  const w = size.width;
+  const a = s.view?.answer;
+  const at = s.updatedAt ? ` \xB7 ${s.updatedAt.toTimeString().slice(0, 8)}` : "";
+  const header = cutWidth(
+    screenText(
+      a ? `mcproc \xB7 ${stacksHostLine(a.host)}${at}${a.host.notes.map((n) => ` \xB7 ${n}`).join("")}` : "mcproc \xB7 reading the stacks\u2026"
+    ),
+    w
+  );
+  const rows = overviewRows(s);
+  const listed = new Set(s.view?.stacks.map((st) => st.project));
+  const cells = rows.map((r, i) => {
+    const mark = i === s.index ? "\u25B6" : " ";
+    if (r.kind === "orphan") return [mark, ...orphanCells(r.orphan)];
+    const st = r.stack;
+    const nested = st.base_project !== st.project && listed.has(st.base_project);
+    return [
+      mark,
+      stackLabel(st, nested),
+      tildePath(st.root),
+      st.hosts.map((h) => h.reachable ? h.name : `${h.name}\u2717`).join(","),
+      st.manifest_error ? "manifest error" : stackApps(st),
+      String(st.apps.errored),
+      st.memory ? fmtBytes(st.memory) : "-",
+      st.cpu === null ? "-" : `${Math.round(st.cpu)}%`,
+      stackPorts(st)
+    ];
+  });
+  const lines = table(
+    [[" ", ...STACK_HEADER], ...cells].map((r) => r.map((c) => screenText(c))),
+    { width: w + 2, flex: [2, 8], cutStart: [2], mode: "fit" }
+  ).split("\n").map((l) => cutWidth(l.replace(/^(.)\s\s/, "$1"), w));
+  const budget = Math.max(2, size.height - CHROME - MIN_APPS);
+  const shown = budget - 1;
+  const start = Math.max(0, Math.min(s.index + 1 - shown, rows.length - shown));
+  const tableShown = [lines[0], ...lines.slice(1 + start, 1 + start + shown)];
+  const sel = selectedOverviewRow(s);
+  let appsTitle = "apps";
+  let apps = [];
+  if (sel?.kind === "stack") {
+    appsTitle = `apps \xB7 ${sel.stack.project}`;
+    apps = stackLines(sel.stack, w);
+  } else if (sel?.kind === "orphan") {
+    const o = sel.orphan;
+    appsTitle = `processes \xB7 pm2 \xB7 ${o.namespace}`;
+    apps = table(
+      [
+        ["NAME", "STATUS", "MEM"],
+        ...o.processes.map((p) => [
+          p.name,
+          p.status,
+          p.memory ? fmtBytes(p.memory) : "-"
+        ])
+      ].map((r) => r.map((c) => screenText(c))),
+      { width: w, flex: [0], mode: "fit" }
+    ).split("\n");
+    if (o.note) apps.push(o.note);
+  } else if (a) {
+    apps = [
+      ...a.host.notes,
+      `no stacks running on this host \xB7 a: ${s.all ? "running only" : "all known"}`
+    ];
+  }
+  const appsH = Math.max(1, size.height - CHROME - tableShown.length);
+  const right = screenText(
+    s.error ? `ERROR: ${s.error}` : s.notice ?? (s.busy ? "working\u2026" : "")
+  );
+  const footer = cutWidth(right ? `${right}  \u2502 ${KEYS(s.all)}` : KEYS(s.all), w);
+  return {
+    header,
+    title: paneTitle("stacks", w),
+    table: tableShown,
+    appsTitle: paneTitle(screenText(appsTitle), w),
+    apps: apps.slice(0, appsH).map((l) => cutWidth(screenText(l), w)),
+    footer
+  };
+}
+function overviewToText(f) {
+  return [f.header, "", ...f.table, "", ...f.apps, "", f.footer].join("\n");
+}
+
+// src/monit/stacks-tui.ts
+function stopNotice(project, r) {
+  const n = r.stopped.length;
+  const parts = [`stopped ${n} app${n === 1 ? "" : "s"} of ${project}`];
+  for (const x of r.readonly)
+    parts.push(`readonly: ${x.host} (${x.apps.length})`);
+  for (const f of r.failed) parts.push(`failed: ${f.host} ${f.message}`);
+  return parts.join(" \xB7 ");
+}
+async function overviewOnce(opts) {
+  const view = await new StacksCollector().collect({
+    all: Boolean(opts.all)
+  });
+  const s = reduceOverview(initialOverview({}), {
+    type: "view",
+    view,
+    at: /* @__PURE__ */ new Date()
+  });
+  return overviewToText(
+    renderOverview(s, { width: opts.width ?? 120, height: 1e3 })
+  );
+}
+async function runOverview(opts) {
+  const screen = blessed2.screen({
+    smartCSR: true,
+    title: "mcproc monit",
+    fullUnicode: true
+  });
+  const box = (o) => blessed2.box({ left: 0, width: "100%", wrap: false, ...o });
+  const header = box({ top: 0, height: 1 });
+  const title = box({ top: 1, height: 1 });
+  const tableBox = box({ top: 2, height: 1 });
+  const appsTitle = box({ top: 3, height: 1 });
+  const appsBox = box({ top: 4, height: 1 });
+  const footer = box({ bottom: 0, height: 1 });
+  const boxes = [header, title, tableBox, appsTitle, appsBox, footer];
+  const attach = () => {
+    for (const b of boxes) screen.append(b);
+  };
+  const detach = () => {
+    for (const b of boxes) b.detach();
+  };
+  attach();
+  const collector = new StacksCollector();
+  let state = initialOverview({ selected: opts.selected });
+  let active = true;
+  let closed = false;
+  let armTimer = null;
+  const paint = () => {
+    if (!active || closed) return;
+    const f = renderOverview(state, {
+      width: screen.width,
+      height: screen.height
+    });
+    header.setContent(f.header);
+    title.setContent(f.title);
+    tableBox.height = f.table.length;
+    tableBox.setContent(f.table.join("\n"));
+    appsTitle.top = 2 + f.table.length;
+    appsTitle.setContent(f.appsTitle);
+    appsBox.top = 3 + f.table.length;
+    appsBox.height = Math.max(
+      1,
+      screen.height - appsBox.top - 1
+    );
+    appsBox.setContent(f.apps.join("\n"));
+    footer.setContent(f.footer);
+    screen.render();
+  };
+  const act = (a) => {
+    state = reduceOverview(state, a);
+    paint();
+  };
+  let inflight = false;
+  const refresh = async () => {
+    if (inflight || closed) return;
+    inflight = true;
+    try {
+      const view = await collector.collect({ all: state.all });
+      act({ type: "view", view, at: /* @__PURE__ */ new Date() });
+    } catch (e) {
+      act({ type: "error", message: describeError(e) });
+    } finally {
+      inflight = false;
+    }
+  };
+  let timer = setInterval(() => void refresh(), opts.intervalMs);
+  return new Promise((resolve) => {
+    const quit = () => {
+      closed = true;
+      clearInterval(timer);
+      if (armTimer) clearTimeout(armTimer);
       screen.destroy();
       resolve();
     };
+    const onKey = async (key) => {
+      const intent = overviewKey(key, state);
+      if (state.armedAt !== null && intent?.kind !== "stop" && !(intent?.kind === "action" && intent.action.type === "arm"))
+        act({ type: "arm", at: null });
+      if (!intent) return;
+      if (intent.kind === "quit") return quit();
+      if (intent.kind === "action") {
+        act(intent.action);
+        if (intent.action.type === "arm" && intent.action.at !== null) {
+          const at = intent.action.at;
+          if (armTimer) clearTimeout(armTimer);
+          armTimer = setTimeout(() => {
+            if (state.armedAt === at) act({ type: "arm", at: null });
+          }, CONFIRM_MS + 50);
+          armTimer.unref();
+        }
+        if (intent.action.type === "toggle-all") void refresh();
+        return;
+      }
+      const m = state.view?.manifests.get(intent.root);
+      if (!m) {
+        act({ type: "notice", message: "that stack is gone; refreshing" });
+        return void refresh();
+      }
+      if (intent.kind === "stop") {
+        act({ type: "busy", busy: true });
+        const r = await stopStack(m);
+        if (closed) return;
+        act({ type: "busy", busy: false });
+        act({ type: "notice", message: stopNotice(m.project, r) });
+        return void refresh();
+      }
+      active = false;
+      clearInterval(timer);
+      detach();
+      const why = await runMonit({
+        project: intent.root,
+        intervalMs: opts.intervalMs,
+        lines: opts.lines,
+        screen,
+        back: true
+      }).catch((e) => {
+        state = reduceOverview(state, {
+          type: "error",
+          message: describeError(e)
+        });
+        return "back";
+      });
+      if (why === "quit") return quit();
+      attach();
+      active = true;
+      timer = setInterval(() => void refresh(), opts.intervalMs);
+      paint();
+      void refresh();
+    };
     screen.on(
       "keypress",
       (_ch, key) => {
-        const intent = keyIntent(key.full ?? key.name ?? "", state);
-        if (state.armedAt !== null && !(intent?.kind === "action" && intent.action.type === "arm"))
-          dispatch({ type: "arm", at: null });
-        if (!intent) return;
-        if (intent.kind === "quit") return quit();
-        if (intent.kind === "action") {
-          if (intent.action.type === "arm" && intent.action.at !== null) {
-            const { at, what } = intent.action;
-            setTimeout(() => {
-              if (state.armedAt === at && state.armed === what)
-                dispatch({ type: "arm", at: null });
-            }, CONFIRM_MS + 50).unref();
-          }
-          if (intent.action.type === "select")
-            loop.dispatchSelect(intent.action.delta);
-          else {
-            dispatch(intent.action);
-            if (intent.action.type === "view") void loop.refresh();
-          }
-          return;
-        }
-        if (intent.kind === "host-next") return void loop.nextView();
-        if (intent.kind === "clear") return void loop.runClear(intent.apps);
-        if (intent.kind === "reload-all") return void loop.reloadAll();
-        void loop.runCommand(intent.cmd, intent.app);
+        if (!active) return;
+        void onKey(key.full ?? key.name ?? "");
       }
     );
     screen.on("resize", paint);
-    void loop.refresh().then(paint);
+    paint();
+    void refresh();
   });
 }
 
@@ -12951,7 +14280,8 @@ var defaultIo = {
   out: (s) => process.stdout.write(`${s}
 `),
   err: (s) => process.stderr.write(`${s}
-`)
+`),
+  columns: () => process.stdout.isTTY ? process.stdout.columns || void 0 : void 0
 };
 async function printSince(fleet, apps, since, how, io, signal) {
   const marks = new LogMarks();
@@ -13003,10 +14333,20 @@ async function printLs(fleet, names, how, io) {
     how.reloads
   );
   io.out(
-    how.json ? JSON.stringify(rows, null, 2) : renderLs(rows, fleet.fallback, unread)
+    how.json ? JSON.stringify(rows, null, 2) : renderLs(rows, fleet.fallback, unread, io.columns?.())
   );
   if (errors.length) process.exitCode = 1;
 }
+function monitMode(g, all, env = process.env, cwd = process.cwd()) {
+  const named = g.project || env.MCPROC_PROJECT || env.CLAUDE_PROJECT_DIR;
+  const found = findManifestPath(
+    named ? resolveProjectDir(g.project, [], env) : cwd
+  );
+  if (all)
+    return found ? { mode: "overview", selected: found.root } : { mode: "overview" };
+  if (!named && !found) return { mode: "overview" };
+  return { mode: "project" };
+}
 function buildProgram(io = defaultIo) {
   const program = new Command().name("mcproc").description(
     "pm2 process control for agents: one manifest per project, local and remote hosts, per-app ports"
@@ -13015,6 +14355,7 @@ function buildProgram(io = defaultIo) {
     "project root (default: MCPROC_PROJECT, CLAUDE_PROJECT_DIR, cwd)"
   ).option("--host <name>", "host from the manifest (default: local)").option("--json", "print JSON instead of text");
   const emit = (g, text, data) => io.out(g.json ? JSON.stringify(data, null, 2) : text);
+  const width = (g) => g.json ? void 0 : io.columns?.();
   const wrap = (fn) => async (...all) => {
     const cmd = all[all.length - 1];
     const opts = all[all.length - 2] ?? {};
@@ -13037,7 +14378,13 @@ Hint: ${e.hint}` : ""}`
     const fleet = fleetOf(g);
     const waits = [];
     const rows = await actOn(fleet, target, act, { ...opts, waits });
-    const { text, failed } = renderMutation(rows, fleet.fallback, act, waits);
+    const { text, failed } = renderMutation(
+      rows,
+      fleet.fallback,
+      act,
+      waits,
+      width(g)
+    );
     emit(g, text, { ...hostsOf(rows, fleet.fallback), rows, waits });
     if (failed) process.exitCode = 1;
   };
@@ -13066,7 +14413,7 @@ ${r.next}`, r);
     wrap(async (g) => {
       const { manifest } = prepare({ project: g.project });
       const h = hostsInfo(manifest);
-      emit(g, renderHosts(h), h);
+      emit(g, renderHosts(h, width(g)), h);
     })
   );
   program.command("doctor").description(
@@ -13099,7 +14446,7 @@ ${r.next}`, r);
       const fleet = fleetOf(g);
       if (!app) {
         const d2 = describeProject(fleet.manifest);
-        emit(g, renderProject(d2), d2);
+        emit(g, renderProject(d2, width(g)), d2);
         return;
       }
       const d = await describeFleetApp(fleet, app);
@@ -13109,7 +14456,7 @@ ${r.next}`, r);
           `${d.app.name} [${d.app.kind}]: ${d.app.description}`,
           `run: ${d.app.run}`,
           `cwd: ${d.app.cwd}`,
-          renderLs([d.row], d.host),
+          renderLs([d.row], d.host, [], width(g)),
           urlNote(d.row),
           `logs: ${d.logs ? `${d.logs.out} | ${d.logs.err}` : "not started yet"}`
         ].filter(Boolean).join("\n"),
@@ -13311,7 +14658,7 @@ ${r.next}`, r);
     wrap(async (g, _o, [port]) => {
       const ctx = await ctxOf(g);
       const r = await portsReport(ctx, port ? Number(port) : void 0);
-      emit(g, renderPorts(r, ctx.host.name), r);
+      emit(g, renderPorts(r, ctx.host.name, width(g)), r);
     })
   );
   program.command("start <target>").description("start an app or profile (dependencies first)").option("--reload", "restart apps that are already online").option("--note <text>", "what this start is for, kept on its lease").addOption(new Option("--lease <id>").hideHelp()).action(
@@ -13337,7 +14684,7 @@ ${r.next}`, r);
         ctx = void 0;
       }
       const v = await leasesView(void 0, ctx);
-      emit(g, renderLeases(v), v);
+      emit(g, renderLeases(v, width(g)), v);
     })
   );
   leases.command("cancel <id>").description("cancel a pending lease").action(
@@ -13346,6 +14693,22 @@ ${r.next}`, r);
       emit(g, `cancelled ${l.id} (${l.project} ${l.target})`, l);
     })
   );
+  program.command("stacks").description(
+    "every mcproc stack on this host: the checkouts any mcproc call has seen and those found in the local pm2, with their hosts, apps, memory and ports"
+  ).option("--all", "also the recorded checkouts with nothing in pm2").action(
+    wrap(async (g, o) => {
+      if (g.host)
+        throw new McprocError(
+          "BAD_ARGUMENT",
+          "stacks reads every host each stack declares; --host does not apply",
+          {
+            hint: "Drop --host."
+          }
+        );
+      const v = await new StacksCollector().collect({ all: Boolean(o.all) });
+      emit(g, renderStacks(v.answer, width(g)), v.answer);
+    })
+  );
   program.command("exec <command...>").description(
     "run a one-off command from the project root with the manifest's exec.env; with --memory, under a lease in the host's queue (use -- before the command)"
   ).option(
@@ -13452,7 +14815,7 @@ ${r.next}`, r);
     wrap(async (g) => {
       const { manifest, deps: deps2 } = await worktreeCtx(g);
       const rows = await worktreeLs(manifest, deps2);
-      emit(g, renderWorktrees(rows), rows);
+      emit(g, renderWorktrees(rows, width(g)), rows);
     })
   );
   worktree.command("remove <ref>").description(
@@ -13477,7 +14840,7 @@ ${r.next}`, r);
       const stop = () => ac.abort();
       process.once("SIGINT", stop);
       process.once("SIGTERM", stop);
-      fs19.mkdirSync(deps2.store.dir, { recursive: true });
+      fs20.mkdirSync(deps2.store.dir, { recursive: true });
       deps2.watch = leaseDirWatch(deps2.store.dir);
       const r = await watchLeases(deps2, { signal: ac.signal });
       io.out(`watcher ${r}`);
@@ -13493,25 +14856,36 @@ ${r.next}`, r);
     })
   );
   program.command("monit").description(
-    "terminal dashboard: apps with real memory/cpu/ports, log tail, details (--once prints one frame)"
+    "terminal dashboard: apps with real memory/cpu/ports, log tail, details (--once prints one frame); outside a project, or with --all, every stack of this host"
+  ).option(
+    "--all",
+    "the stacks overview: every stack of this host, Enter opens one"
   ).option("--once", "print one frame as text and exit").option("--interval <ms>", "refresh interval", "2000").option("--lines <n>", "log lines of history", "200").action(
     wrap(async (g, o) => {
+      const lines = Number(o.lines) || 200;
+      const intervalMs = Math.max(500, Number(o.interval) || 2e3);
+      const m = monitMode(g, Boolean(o.all));
+      if (m.mode === "overview") {
+        if (g.host)
+          throw new McprocError(
+            "BAD_ARGUMENT",
+            "--host names a host of one manifest; the overview reads every stack",
+            {
+              hint: "Drop --host, or open the project: mcproc --project <root> monit --host <name>."
+            }
+          );
+        if (o.once) {
+          io.out(await overviewOnce({ width: io.columns?.() }));
+          return;
+        }
+        await runOverview({ intervalMs, lines, selected: m.selected });
+        return;
+      }
       if (o.once) {
-        io.out(
-          await monitOnce({
-            project: g.project,
-            host: g.host,
-            lines: Number(o.lines) || 200
-          })
-        );
+        io.out(await monitOnce({ project: g.project, host: g.host, lines }));
         return;
       }
-      await runMonit({
-        project: g.project,
-        host: g.host,
-        intervalMs: Math.max(500, Number(o.interval) || 2e3),
-        lines: Number(o.lines) || 200
-      });
+      await runMonit({ project: g.project, host: g.host, intervalMs, lines });
     })
   );
   program.command("unpack").description(