@gamecrate/cli 0.1.0 → 1.1.0

package/dist/gamecrate.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { existsSync as existsSync7 } from "node:fs";
-import { chown, cp, mkdir as mkdir4, readdir as readdir8, readFile as readFile5, rm as rm2, rmdir, stat as stat4, writeFile as writeFile4 } from "node:fs/promises";
+import { existsSync as existsSync8 } from "node:fs";
+import { chown, cp, mkdir as mkdir4, readdir as readdir9, readFile as readFile7, rm as rm3, rmdir, stat as stat4, writeFile as writeFile5 } from "node:fs/promises";
 import { homedir as homedir5 } from "node:os";
-import { basename as basename7, dirname as dirname5, join as join14 } from "node:path";
-import { setTimeout as sleep4 } from "node:timers/promises";
+import { basename as basename10, dirname as dirname5, join as join16 } from "node:path";
+import { setTimeout as sleep5 } from "node:timers/promises";
 
 // src/cli/args.ts
 import { Command, CommanderError, Option } from "commander";
@@ -23,6 +23,9 @@ var Exit = {
   Stale: 8,
   Interrupted: 130
 };
+function reasonFor(code) {
+  return code === Exit.Interrupted ? "stopped" : "exited";
+}
 
 class GamecrateError extends Error {
   code;
@@ -49,7 +52,11 @@ var RESERVED_NAMES = [
   "verify",
   "help",
   "version",
-  "modless"
+  "modless",
+  "ps",
+  "stop",
+  "attach",
+  "wait"
 ];
 var NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
 function own(bag, key) {
@@ -74,6 +81,8 @@ var RUN_FLAGS = [
   "--no-stale-check",
   "--replace",
   "--no-replace",
+  "--detach",
+  "--no-detach",
   "--sort",
   "--docker-arg",
   "--dry-run",
@@ -116,7 +125,7 @@ var SUBCOMMANDS = [
   {
     name: "clean",
     summary: "tiered wipe of a profile",
-    usage: "<game> <profile>",
+    usage: "<game> [profile]",
     positionals: ["game", "profile"],
     flags: ["--staging", "--logs", "--all", "--yes", "--instance", "--worktree", "--no-worktree"]
   },
@@ -130,7 +139,35 @@ var SUBCOMMANDS = [
   {
     name: "logs",
     summary: "tail or open the last run's captured logs",
-    usage: "<game> <profile>",
+    usage: "<game> [profile]",
+    positionals: ["game", "profile"],
+    flags: ["--instance", "--worktree", "--no-worktree", "--follow"]
+  },
+  {
+    name: "attach",
+    summary: "stream a detached run's output; ctrl-c leaves the game running",
+    usage: "<game> [profile]",
+    positionals: ["game", "profile"],
+    flags: ["--instance", "--worktree", "--no-worktree"]
+  },
+  {
+    name: "wait",
+    summary: "block until a detached run ends, then exit with its code",
+    usage: "<game> [profile]",
+    positionals: ["game", "profile"],
+    flags: ["--instance", "--worktree", "--no-worktree"]
+  },
+  {
+    name: "ps",
+    summary: "every live run: game, profile/instance, mode, pid, container, uptime or status",
+    usage: "",
+    positionals: [],
+    flags: []
+  },
+  {
+    name: "stop",
+    summary: "stop a detached run and release its lock",
+    usage: "<game> [profile]",
     positionals: ["game", "profile"],
     flags: ["--instance", "--worktree", "--no-worktree"]
   },
@@ -169,7 +206,7 @@ var SUBCOMMANDS = [
   },
   {
     name: "config",
-    summary: "open profiles.json in $EDITOR, validate on save",
+    summary: "open the global config in $VISUAL or $EDITOR, validate on save",
     usage: "edit",
     positionals: ["rest"],
     flags: []
@@ -231,7 +268,7 @@ function enumOption(flags, summary, values) {
 }
 function buildProgram() {
   const program = new Command;
-  program.name("gamecrate").exitOverride().helpOption(false).allowExcessArguments(true).showSuggestionAfterError(false).configureOutput({ writeOut: () => {}, writeErr: () => {} }).argument("[args...]").option("--mod <id>", "add a mod to the profile set", collect, []).option("--without <id>", "drop a mod from the resolved set", collect, []).option("--only <id>", "restrict the resolved set to these mods", collect, []).option("--worktree <path>", "promote mods from this git worktree, in its own instance ($GAMECRATE_WORKTREE)", collect, []).option("--use <packageId>=<path>", "force one mod to load from this directory, whatever the profile pins", collect, []).option("--no-worktree", "ignore the current worktree and $GAMECRATE_WORKTREE").option("--instance <name>", "run under a named sub-profile with its own saves, logs and container").addOption(enumOption(`--mode <${MODES.join("|")}>`, "how the game is displayed", MODES)).option("--marker <str>", "exit 0 as soon as this string appears in the log").option("--timeout <seconds>", "kill the container after this long", (v) => seconds("--timeout", v)).option("--render-wait <seconds>", "settle time before a screenshot is taken", (v) => seconds("--render-wait", v)).option("--resolution <width>x<height>", "override the game resolution", parseResolution).addOption(enumOption(`--network <${NETWORK_POLICIES.join("|")}>`, "the container's network mode", NETWORK_POLICIES)).option("--log <path>", "route launch stdout and stderr to one file").addOption(enumOption(`--pull <${PULL_POLICIES.join("|")}>`, "when to pull the runtime image", PULL_POLICIES)).option("--build", "build local C# mods before launching").option("--no-build", "never build, even when an assembly is stale").option("--no-stale-check", "do not warn when a mod's sources are newer than its assemblies").option("--replace", "stop whatever is holding this profile and instance, then launch").option("--no-replace", "refuse when this profile and instance are already running").addOption(enumOption(`--sort <${SORTS.join("|")}>`, "load order: the profile order, or a topological sort", SORTS)).option("--docker-arg <arg>", "one extra argv element for docker run", collect, []).option("--dry-run", "resolve and validate fully, write nothing").option("--print-plan", "print the resolved launch plan instead of launching").option("--json", "machine-readable output").option("--root", "run as root instead of mapping the host uid").option("--staging", "clean: wipe .stage only (the default)").option("--logs", "clean: wipe the captured run logs").option("--all", "clean: wipe the whole profile, saves included (needs --yes)").option("-y, --yes", "skip destructive-action confirmation").option("-h, --help", "this help");
+  program.name("gamecrate").exitOverride().helpOption(false).allowExcessArguments(true).showSuggestionAfterError(false).configureOutput({ writeOut: () => {}, writeErr: () => {} }).argument("[args...]").option("--mod <id>", "add a mod to the profile set", collect, []).option("--without <id>", "drop a mod from the resolved set", collect, []).option("--only <id>", "restrict the resolved set to these mods", collect, []).option("--worktree <path>", "promote mods from this git worktree, in its own instance ($GAMECRATE_WORKTREE)", collect, []).option("--use <packageId>=<path>", "force one mod to load from this directory, whatever the profile pins", collect, []).option("--no-worktree", "ignore the current worktree and $GAMECRATE_WORKTREE").option("--instance <name>", "run under a named sub-profile with its own saves, logs and container").addOption(enumOption(`--mode <${MODES.join("|")}>`, "how the game is displayed", MODES)).option("--marker <str>", "exit 0 as soon as this string appears in the log").option("--timeout <seconds>", "bound a marker run, or a headless run with no marker", (v) => seconds("--timeout", v)).option("--render-wait <seconds>", "settle time before a screenshot is taken", (v) => seconds("--render-wait", v)).option("--resolution <width>x<height>", "override the game resolution", parseResolution).addOption(enumOption(`--network <${NETWORK_POLICIES.join("|")}>`, "the container's network mode", NETWORK_POLICIES)).option("--log <path>", "route launch stdout and stderr to one file").addOption(enumOption(`--pull <${PULL_POLICIES.join("|")}>`, "when to pull the runtime image", PULL_POLICIES)).option("--build", "build local C# mods before launching").option("--no-build", "never build, even when an assembly is stale").option("--no-stale-check", "do not warn when a mod's sources are newer than its assemblies").option("--replace", "stop whatever is holding this profile and instance, then launch").option("--no-replace", "refuse when this profile and instance are already running").option("--detach", "start the run in the background and return the prompt").option("--no-detach", "stay in the foreground, whatever the profile or project config asks for").addOption(new Option("--supervised <instanceDir>").hideHelp()).addOption(enumOption(`--sort <${SORTS.join("|")}>`, "load order: the profile order, or a topological sort", SORTS)).option("--docker-arg <arg>", "one extra argv element for docker run", collect, []).option("--dry-run", "resolve and validate fully, write nothing").option("--print-plan", "print the resolved launch plan instead of launching").option("--json", "machine-readable output").option("--root", "run as root instead of mapping the host uid").option("--staging", "clean: wipe .stage only (the default)").option("--logs", "clean: wipe the captured run logs").option("--all", "clean: wipe the whole profile, saves included (needs --yes)").option("-f, --follow", "keep printing as the run writes").option("-y, --yes", "skip destructive-action confirmation").option("-h, --help", "this help");
   return program;
 }
 function checkValueTokens(program, head) {
@@ -298,6 +335,14 @@ function parseArgs(argv, opts = {}) {
     throw usage("--build and --no-build contradict");
   if (seen.has("--replace") && seen.has("--no-replace"))
     throw usage("--replace and --no-replace contradict");
+  if (seen.has("--detach")) {
+    if (seen.has("--no-detach"))
+      throw usage("--detach and --no-detach contradict");
+    if (seen.has("--dry-run"))
+      throw usage("--detach and --dry-run contradict");
+    if (seen.has("--print-plan"))
+      throw usage("--detach and --print-plan contradict");
+  }
   const values = program.opts();
   const envBuild = applyEnv(program, seen, env, values);
   const out = {
@@ -313,10 +358,15 @@ function parseArgs(argv, opts = {}) {
     root: values["root"] === true,
     yes: values["yes"] === true,
     help: values["help"] === true,
+    follow: values["follow"] === true,
     worktree,
     noWorktree: seen.has("--no-worktree"),
     noStaleCheck: seen.has("--no-stale-check"),
     replace: values["replace"] === true,
+    noReplace: seen.has("--no-replace"),
+    detach: values["detach"] === true,
+    noDetach: seen.has("--no-detach"),
+    supervised: typeof values["supervised"] === "string",
     use: values["use"],
     rest: []
   };
@@ -334,11 +384,12 @@ function parseArgs(argv, opts = {}) {
   out.cleanTier = cleanTier;
   if (opts.defaults?.game !== undefined)
     out.game = opts.defaults.game;
-  if (opts.defaults?.profile !== undefined)
-    out.profile = opts.defaults.profile;
   applyPositionals(out, program.args, opts.games);
   if (opts.defaults !== undefined)
     applyDefaults(out, seen, opts.defaults, sep !== -1);
+  if (seen.has("--detach") && out.subcommand === "shell") {
+    throw usage("shell cannot detach: a shell needs the terminal --detach gives up");
+  }
   return out;
 }
 function policy(value) {
@@ -486,6 +537,17 @@ function applyDefaults(out, seen, defaults, hasGameArgs) {
     out.noStaleCheck = defaults.noStaleCheck ?? out.noStaleCheck;
   if (!seen.has("--replace") && !seen.has("--no-replace"))
     out.replace = defaults.replace ?? out.replace;
+  if (!seen.has("--detach") && !seen.has("--no-detach"))
+    out.detach = defaults.detach ?? out.detach;
+}
+function wantsDetach(args, profile) {
+  return !args.supervised && !args.noDetach && (args.detach || profile.detach === true);
+}
+function wantsReplace(args, profile) {
+  return !args.supervised && !args.noReplace && (args.replace || profile.replace === true);
+}
+function buildPolicy(args, profile) {
+  return args.build ?? profile.build ?? "auto";
 }
 function truthy(value) {
   return value === "1" || value.toLowerCase() === "true" || value.toLowerCase() === "yes";
@@ -538,11 +600,107 @@ function distance(a, b) {
   }
   return prev[b.length];
 }
+function supervisorArgv(userArgs, instanceDir, self = process.argv, execPath = process.execPath) {
+  const bin = self[1]?.startsWith("/$bunfs/") === true ? [execPath] : [execPath, self[1]];
+  const sep = userArgs.indexOf("--");
+  const head = [
+    ...(sep === -1 ? userArgs : userArgs.slice(0, sep)).filter((arg) => arg !== "--detach"),
+    "--supervised",
+    instanceDir
+  ];
+  const tail = sep === -1 ? [] : userArgs.slice(sep);
+  return [...bin, ...head, ...tail];
+}
+function supervisedDir(argv) {
+  const sep = argv.indexOf("--");
+  const head = sep === -1 ? argv : argv.slice(0, sep);
+  const at = head.indexOf("--supervised");
+  return at === -1 ? undefined : head[at + 1];
+}
+
+// src/cli/game.ts
+function requireGame(args, config) {
+  const game = args.game;
+  if (game === undefined) {
+    throw new GamecrateError(`${args.subcommand} needs a game`, Exit.Usage, `known games: ${Object.keys(config.games).join(", ")}`);
+  }
+  if (!Object.hasOwn(config.games, game)) {
+    throw new GamecrateError(`unknown game "${game}"`, Exit.Config, `known games: ${Object.keys(config.games).join(", ")}`);
+  }
+  return game;
+}
+
+// src/cli/list.ts
+import { basename } from "node:path";
+function list(args, config, defaults) {
+  const games = args.game === undefined ? Object.keys(config.games) : [requireGame(args, config)];
+  const fromProject = (game, profile) => defaults.game === game && own(defaults.profiles, profile) !== undefined;
+  if (args.json) {
+    const payload = games.map((name) => {
+      const game = config.games[name];
+      return {
+        game: name,
+        core: game.core,
+        dlc: game.dlc,
+        modes: game.modes,
+        profiles: Object.entries(game.profiles).map(([profile, spec]) => ({
+          profile,
+          alias: spec.alias ?? null,
+          description: spec.description ?? null,
+          extends: spec.extends ?? null,
+          mods: spec.mods?.length ?? 0,
+          instances: Object.keys(spec.instances ?? {}),
+          source: fromProject(name, profile) ? "project" : "config"
+        }))
+      };
+    });
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}
+`);
+    return Exit.Ok;
+  }
+  const source = defaults.configPath === undefined ? "the .gamecrate project config" : basename(defaults.configPath);
+  const out = [];
+  for (const name of games) {
+    const game = config.games[name];
+    const width = Math.max(7, ...Object.keys(game.profiles).map((n) => n.length));
+    out.push(`${name}  (${game.modes.join(", ")})`);
+    out.push(`  ${"modless".padEnd(width)}  built-in: core + official DLC`);
+    for (const [profile, spec] of Object.entries(game.profiles)) {
+      const notes = [];
+      if (spec.alias)
+        notes.push(`alias for ${spec.alias}`);
+      if (spec.extends)
+        notes.push(`extends ${spec.extends}`);
+      const count = spec.mods?.length ?? 0;
+      if (!spec.alias)
+        notes.push(count === 1 ? "1 entry" : `${count} entries`);
+      if (spec.aliases?.length)
+        notes.push(`aka ${spec.aliases.join(", ")}`);
+      if (fromProject(name, profile))
+        notes.push(`from ${source}`);
+      out.push(`  ${profile.padEnd(width)}  ${notes.join(", ")}`);
+      if (spec.description)
+        out.push(`  ${" ".repeat(width)}  ${spec.description}`);
+      const instances = Object.keys(spec.instances ?? {});
+      if (instances.length > 0)
+        out.push(`  ${" ".repeat(width)}  instances: ${instances.join(", ")}`);
+    }
+  }
+  process.stdout.write(`${out.join(`
+`)}
+`);
+  return Exit.Ok;
+}
+
+// src/cli/profile.ts
+function profileOf(args, defaults) {
+  return args.profile ?? defaults.defaultProfile ?? defaults.profileOrder?.[0] ?? "modless";
+}
 
 // src/cli/help.ts
 var NAME = "gamecrate";
 function flags() {
-  return buildProgram().options;
+  return buildProgram().options.filter((o) => !o.hidden);
 }
 function renderHelp(topic, config) {
   if (!topic)
@@ -712,13 +870,21 @@ ${fn} "$@"
 }
 
 // src/cli/output.ts
-import { closeSync, existsSync as existsSync2, lstatSync, mkdirSync, openSync, readdirSync, rmSync, symlinkSync, unlinkSync, writeSync } from "node:fs";
-import { basename as basename2, join as join3, resolve } from "node:path";
+import { closeSync, existsSync as existsSync2, lstatSync, mkdirSync as mkdirSync2, openSync, readdirSync, rmSync, symlinkSync, unlinkSync, writeSync } from "node:fs";
+import { basename as basename3, join as join4, resolve } from "node:path";
+
+// src/docker/run.ts
+import { spawn } from "node:child_process";
+import { createWriteStream, mkdirSync } from "node:fs";
+import { open, readdir, stat } from "node:fs/promises";
+import { join as join2 } from "node:path";
+import { setTimeout as sleep } from "node:timers/promises";
+import { TextDecoder } from "node:util";
 
 // src/docker/spec.ts
 import { existsSync, realpathSync } from "node:fs";
 import { homedir, hostname } from "node:os";
-import { basename, join } from "node:path";
+import { basename as basename2, join } from "node:path";
 var CONTAINER_RUNTIME_DIR = "/tmp/xdg";
 var CONTAINER_LOG_DIR = "/logs";
 var X11_SOCKET_DIR = "/tmp/.X11-unix";
@@ -956,7 +1122,7 @@ function waylandSocket() {
   const source = display.startsWith("/") ? display : runtime ? join(runtime, display) : null;
   if (!source || !existsSync(source))
     return null;
-  return { source, name: basename(source) };
+  return { source, name: basename2(source) };
 }
 function audioSockets() {
   const runtime = process.env.XDG_RUNTIME_DIR;
@@ -978,9 +1144,150 @@ function hostPath(path) {
   }
 }
 
+// src/docker/run.ts
+function spawnArgv(argv, stdio, detached = false) {
+  return spawn(argv[0], argv.slice(1), { stdio, detached });
+}
+function exited(proc) {
+  return new Promise((resolve, reject) => {
+    proc.once("error", reject);
+    proc.once("close", (code) => resolve(code ?? 1));
+  });
+}
+async function collect2(stream) {
+  const chunks = [];
+  for await (const chunk of stream)
+    chunks.push(chunk);
+  return Buffer.concat(chunks).toString("utf8");
+}
+async function capture(argv) {
+  try {
+    const proc = spawnArgv(argv, ["ignore", "pipe", "pipe"]);
+    const [stdout, stderr, code] = await Promise.all([
+      collect2(proc.stdout),
+      collect2(proc.stderr),
+      exited(proc)
+    ]);
+    return { code, stdout, stderr };
+  } catch (error) {
+    return { code: 127, stdout: "", stderr: error instanceof Error ? error.message : String(error) };
+  }
+}
+var STDOUT_LOG = "stdout.log";
+var MARKER_POLL_MS = 200;
+async function runContainer(spec, opts) {
+  const stopTimeout = opts.stopTimeoutSeconds ?? 10;
+  mkdirSync(opts.logDir, { recursive: true });
+  const sink = createWriteStream(join2(opts.logDir, STDOUT_LOG));
+  const proc = spawnArgv(["docker", ...toDockerArgs(spec)], ["inherit", "pipe", "pipe"]);
+  let interrupted = false;
+  const onSignal = () => {
+    if (interrupted)
+      return;
+    interrupted = true;
+    stopContainer(spec.name, stopTimeout);
+  };
+  process.on("SIGINT", onSignal);
+  process.on("SIGTERM", onSignal);
+  const code = exited(proc);
+  try {
+    await Promise.all([
+      tee(proc.stdout, sink, process.stdout),
+      tee(proc.stderr, sink, process.stderr)
+    ]);
+    const status = await code;
+    return interrupted ? Exit.Interrupted : status;
+  } finally {
+    process.off("SIGINT", onSignal);
+    process.off("SIGTERM", onSignal);
+    await new Promise((resolve) => sink.end(resolve));
+  }
+}
+var STOP_TIMEOUT_SECONDS = 10;
+async function stopContainer(name, timeoutSeconds) {
+  const proc = spawnArgv(["docker", "stop", "--timeout", String(timeoutSeconds), name], "ignore");
+  await exited(proc).catch(() => {});
+}
+async function waitForMarker(sources, marker, timeoutSeconds) {
+  const deadline = Date.now() + timeoutSeconds * 1000;
+  const carry = Math.max(marker.length - 1, 0);
+  const seen = new Map;
+  const startedAt = Date.now();
+  while (true) {
+    for (const path of await expandSources(sources)) {
+      let state = seen.get(path);
+      if (state === undefined) {
+        state = { offset: await staleSize(path, startedAt), tail: "", decoder: new TextDecoder };
+        seen.set(path, state);
+      }
+      if (await scan(path, state, marker, carry))
+        return true;
+    }
+    if (Date.now() >= deadline)
+      return false;
+    await sleep(Math.min(MARKER_POLL_MS, Math.max(deadline - Date.now(), 0)));
+  }
+}
+async function staleSize(path, startedAt) {
+  return stat(path).then((info) => info.mtimeMs < startedAt ? info.size : 0, () => 0);
+}
+async function scan(path, state, marker, carry) {
+  const handle = await open(path, "r").catch(() => null);
+  if (handle === null)
+    return false;
+  try {
+    const { size } = await handle.stat();
+    if (size < state.offset) {
+      state.offset = 0;
+      state.tail = "";
+      state.decoder = new TextDecoder;
+    }
+    if (size <= state.offset)
+      return false;
+    const buffer = Buffer.alloc(size - state.offset);
+    const { bytesRead } = await handle.read(buffer, 0, buffer.length, state.offset);
+    state.offset += bytesRead;
+    const text = state.tail + state.decoder.decode(buffer.subarray(0, bytesRead), { stream: true });
+    if (text.includes(marker))
+      return true;
+    state.tail = carry > 0 ? text.slice(-carry) : "";
+    return false;
+  } catch {
+    return false;
+  } finally {
+    await handle.close().catch(() => {});
+  }
+}
+async function expandSources(sources) {
+  const out = [];
+  for (const source of sources) {
+    const info = await stat(source).catch(() => null);
+    if (info === null) {
+      out.push(source);
+      continue;
+    }
+    if (!info.isDirectory()) {
+      out.push(source);
+      continue;
+    }
+    const entries = await readdir(source).catch(() => []);
+    for (const entry of entries) {
+      if (entry.toLowerCase().endsWith(".log"))
+        out.push(join2(source, entry));
+    }
+  }
+  return out;
+}
+async function tee(stream, sink, mirror) {
+  for await (const chunk of stream) {
+    mirror.write(chunk);
+    sink.write(chunk);
+  }
+}
+
 // src/mods/staleness.ts
-import { readdir, stat } from "node:fs/promises";
-import { join as join2, relative } from "node:path";
+import { readdir as readdir2, stat as stat2 } from "node:fs/promises";
+import { join as join3, relative } from "node:path";
 var SKIP_DIRS = new Set([".git", ".retired", ".vs", "bin", "node_modules", "obj"]);
 var ENTRY_LIMIT = 20000;
 async function scanBuildTimes(dir) {
@@ -989,14 +1296,14 @@ async function scanBuildTimes(dir) {
   const walk = async (current, inAssemblies) => {
     let entries;
     try {
-      entries = await readdir(current, { withFileTypes: true });
+      entries = await readdir2(current, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
       if (budget-- <= 0)
         return;
-      const path = join2(current, entry.name);
+      const path = join3(current, entry.name);
       if (entry.isDirectory()) {
         if (SKIP_DIRS.has(entry.name.toLowerCase()))
           continue;
@@ -1012,7 +1319,7 @@ async function scanBuildTimes(dir) {
         continue;
       let mtimeMs;
       try {
-        mtimeMs = (await stat(path)).mtimeMs;
+        mtimeMs = (await stat2(path)).mtimeMs;
       } catch {
         continue;
       }
@@ -1060,14 +1367,14 @@ function staleWarning(packageId, report, now = Date.now()) {
 `);
 }
 function duration(ms) {
-  const seconds2 = Math.max(0, Math.round(ms / 1000));
-  if (seconds2 < 60)
-    return `${seconds2}s`;
-  if (seconds2 < 3600)
-    return `${Math.floor(seconds2 / 60)}m`;
-  if (seconds2 < 86400)
-    return `${Math.floor(seconds2 / 3600)}h`;
-  return `${Math.floor(seconds2 / 86400)}d`;
+  const seconds = Math.max(0, Math.round(ms / 1000));
+  if (seconds < 60)
+    return `${seconds}s`;
+  if (seconds < 3600)
+    return `${Math.floor(seconds / 60)}m`;
+  if (seconds < 86400)
+    return `${Math.floor(seconds / 3600)}h`;
+  return `${Math.floor(seconds / 86400)}d`;
 }
 function ago(mtimeMs, now = Date.now()) {
   return `${duration(now - mtimeMs)} ago`;
@@ -1080,8 +1387,8 @@ function status(message) {
 function warn(message) {
   process.stderr.write(line(`warning: ${message}`));
 }
-function redirectOutput(path) {
-  const fd = openSync(path, "w");
+function redirectOutput(path, keep = false) {
+  const fd = openSync(path, keep ? "a" : "w");
   const stdout = process.stdout.write;
   const stderr = process.stderr.write;
   let open = true;
@@ -1115,8 +1422,7 @@ function line(message) {
 }
 function reportProblems(problems) {
   if (problems.length === 0) {
-    process.stderr.write(line("resolution failed with no reported detail"));
-    process.exit(Exit.Resolution);
+    throw new GamecrateError("resolution failed with no reported detail", Exit.Resolution);
   }
   const groups = new Map;
   for (const problem of problems) {
@@ -1126,7 +1432,7 @@ function reportProblems(problems) {
     else
       groups.set(problem.where, [problem]);
   }
-  const out = [`${problems.length} problem${problems.length === 1 ? "" : "s"}:`];
+  const out = [];
   for (const [where, group] of groups) {
     out.push(`  ${where}`);
     for (const problem of group) {
@@ -1135,10 +1441,8 @@ function reportProblems(problems) {
         out.push(`      did you mean ${problem.suggestion}?`);
     }
   }
-  process.stderr.write(`${out.join(`
-`)}
-`);
-  process.exit(Exit.Resolution);
+  throw new GamecrateError(`${problems.length} problem${problems.length === 1 ? "" : "s"}`, Exit.Resolution, out.join(`
+`));
 }
 function planWarnings(plan) {
   if (!plan.warnOnStale)
@@ -1212,10 +1516,10 @@ function runTimestamp(now = new Date) {
   return now.toISOString().replace(/[-:.]/g, "");
 }
 function openRunLog(logsDir, now) {
-  const runsDir = join3(logsDir, "runs");
-  mkdirSync(runsDir, { recursive: true });
+  const runsDir = join4(logsDir, "runs");
+  mkdirSync2(runsDir, { recursive: true });
   const dir = uniqueRunDir(runsDir, runTimestamp(now));
-  mkdirSync(dir);
+  mkdirSync2(dir);
   linkCurrent(logsDir, dir);
   rotateRuns(logsDir, 10);
   return dir;
@@ -1225,40 +1529,66 @@ function append(fd, chunk) {
   writeSync(fd, typeof chunk === "string" ? encoder.encode(chunk) : chunk);
 }
 function uniqueRunDir(runsDir, stamp) {
-  let candidate = join3(runsDir, stamp);
+  let candidate = join4(runsDir, stamp);
   for (let n = 2;existsSync2(candidate); n++)
-    candidate = join3(runsDir, `${stamp}-${n}`);
+    candidate = join4(runsDir, `${stamp}-${n}`);
   return candidate;
 }
+var WAIT_NOTICE = { firstMs: 2000, everyMs: 30000 };
+function waitNotice(waitedMs, lastNoticeMs, schedule = WAIT_NOTICE) {
+  if (waitedMs < schedule.firstMs)
+    return;
+  if (lastNoticeMs > 0 && waitedMs - lastNoticeMs < schedule.everyMs)
+    return;
+  return waitedMs < 60000 ? `${Math.floor(waitedMs / 1000)}s` : `${Math.floor(waitedMs / 60000)}m`;
+}
+function runStartedAt(name) {
+  const m = /^(\d{4})(\d{2})(\d{2})T(\d{2})(\d{2})(\d{2})(\d{3})Z/.exec(name);
+  if (m === null)
+    return;
+  const at = Date.parse(`${m[1]}-${m[2]}-${m[3]}T${m[4]}:${m[5]}:${m[6]}.${m[7]}Z`);
+  return Number.isNaN(at) ? undefined : at;
+}
+function currentLog(instanceDir) {
+  return join4(instanceDir, "logs", "current", STDOUT_LOG);
+}
+function tailArgv(file, fromStart, livePid) {
+  const argv = ["tail"];
+  if (fromStart)
+    argv.push("-n", "+1");
+  if (livePid !== undefined)
+    argv.push("-f", "--pid", String(livePid));
+  argv.push(file);
+  return argv;
+}
 function linkCurrent(logsDir, target) {
-  const link = join3(logsDir, "current");
+  const link = join4(logsDir, "current");
   try {
     lstatSync(link);
     unlinkSync(link);
   } catch {}
-  symlinkSync(join3("runs", basename2(target)), link, "dir");
+  symlinkSync(join4("runs", basename3(target)), link, "dir");
 }
 function rotateRuns(logsDir, keep) {
-  const runsDir = join3(logsDir, "runs");
+  const runsDir = join4(logsDir, "runs");
   if (keep < 1 || !existsSync2(runsDir))
     return [];
   const dirs = readdirSync(runsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort().reverse();
   const removed = dirs.slice(keep);
   for (const name of removed)
-    rmSync(join3(runsDir, name), { recursive: true, force: true });
+    rmSync(join4(runsDir, name), { recursive: true, force: true });
   return removed;
 }
 
 // src/config/load.ts
-import { parse as parseYaml } from "yaml";
 import { z as z2 } from "zod";
-import { access, readdir as readdir2, readFile } from "node:fs/promises";
+import { access, readdir as readdir3, readFile as readFile2 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import { dirname as dirname2, join as join5, resolve as resolve3 } from "node:path";
+import { basename as basename4, dirname as dirname2, join as join6, resolve as resolve3 } from "node:path";
 
 // src/plugin.ts
 import { readFileSync, statSync } from "node:fs";
-import { dirname, isAbsolute, join as join4, resolve as resolve2 } from "node:path";
+import { dirname, isAbsolute, join as join5, resolve as resolve2 } from "node:path";
 import { pathToFileURL } from "node:url";
 import { exports as exportsField, legacy } from "resolve.exports";
 var PLUGIN_API_VERSION = 1;
@@ -1274,7 +1604,7 @@ function fail(spec, message, detail) {
 function entryOf(dir) {
   let manifest;
   try {
-    manifest = JSON.parse(readFileSync(join4(dir, "package.json"), "utf8"));
+    manifest = JSON.parse(readFileSync(join5(dir, "package.json"), "utf8"));
   } catch {
     return resolve2(dir, "index.js");
   }
@@ -1288,8 +1618,8 @@ function entryOf(dir) {
 function packageDir(spec, from) {
   let dir = resolve2(from);
   for (;; ) {
-    const candidate = join4(dir, "node_modules", spec);
-    if (statSync(join4(candidate, "package.json"), { throwIfNoEntry: false })?.isFile())
+    const candidate = join5(dir, "node_modules", spec);
+    if (statSync(join5(candidate, "package.json"), { throwIfNoEntry: false })?.isFile())
       return candidate;
     const parent = dirname(dir);
     if (parent === dir)
@@ -1374,6 +1704,12 @@ var DEFAULT_SETTINGS = {
   pidsLimit: 1024
 };
 
+// src/config/read.ts
+import { readFile } from "node:fs/promises";
+import { extname } from "node:path";
+import { parseTree } from "jsonc-parser";
+import { isMap, parse as parseYaml, parseDocument } from "yaml";
+
 // src/config/jsonc.ts
 import { parse, printParseErrorCode } from "jsonc-parser";
 function parseJsonc(text) {
@@ -1386,6 +1722,59 @@ function parseJsonc(text) {
   return value;
 }
 
+// src/config/read.ts
+var CONFIG_SUFFIXES = [".yml", ".yaml", ".json", ".jsonc"];
+function isYaml(path) {
+  const suffix = extname(path).toLowerCase();
+  if (suffix === ".yml" || suffix === ".yaml")
+    return true;
+  if (suffix === ".json" || suffix === ".jsonc")
+    return false;
+  throw new GamecrateError(`config is not a format gamecrate reads: ${path}`, Exit.Config, `use one of ${CONFIG_SUFFIXES.join(", ")}`);
+}
+function readConfigText(text, path) {
+  if (!isYaml(path)) {
+    try {
+      return parseJsonc(text);
+    } catch (error) {
+      if (error instanceof GamecrateError) {
+        throw new GamecrateError(`${error.message}: ${path}`, error.code, error.detail);
+      }
+      throw error;
+    }
+  }
+  try {
+    return parseYaml(text);
+  } catch (error) {
+    throw new GamecrateError(`config is invalid: ${path}`, Exit.Config, error.message);
+  }
+}
+async function readConfigFile(path) {
+  let text;
+  try {
+    text = await readFile(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return;
+    throw error;
+  }
+  return readConfigText(text, path);
+}
+function orderedKeys(text, path, key) {
+  if (isYaml(path)) {
+    const node = parseDocument(text).get(key, true);
+    if (!isMap(node))
+      return [];
+    return node.items.map((item) => String(item.key.value ?? item.key));
+  }
+  const root = parseTree(text);
+  const holder = root?.children?.find((child) => child.children?.[0]?.value === key);
+  const value = holder?.children?.[1];
+  if (value?.type !== "object")
+    return [];
+  return (value.children ?? []).map((prop) => String(prop.children?.[0]?.value));
+}
+
 // src/config/validate.ts
 import { z } from "zod";
 var MODES2 = ["headed", "headless", "screenshot"];
@@ -1399,7 +1788,11 @@ function obj(shape) {
 function hintsFor(message) {
   if (!message.startsWith(HINTS))
     return [];
-  return JSON.parse(message.slice(HINTS.length));
+  try {
+    return JSON.parse(message.slice(HINTS.length));
+  } catch {
+    return [];
+  }
 }
 function requiredWhen(key, when) {
   return (ctx) => {
@@ -1491,7 +1884,11 @@ var profile = obj({
     error: "expected an object"
   }).optional(),
   alias: str.optional(),
-  aliases: strArray.optional()
+  aliases: strArray.optional(),
+  description: str.optional(),
+  detach: bool.optional(),
+  replace: bool.optional(),
+  build: oneOf(["auto", "always", "never"]).optional()
 }).check((ctx) => {
   const v = ctx.value;
   if (v.alias !== undefined && (v.extends !== undefined || v.mods !== undefined)) {
@@ -1556,34 +1953,34 @@ function validateConfig(cfg) {
     problems.push({ where: "", message: "expected the config to be an object" });
     return { config: { dataRoot: "", games: {} }, problems };
   }
-  collect2(problems, "", root, cfg);
+  collect3(problems, "", root, cfg);
   const games = cfg["games"];
   if (!isObj(games)) {
     problems.push({ where: "/games", message: 'missing required key "games", or it is not an object' });
     return { config: cfg, problems };
   }
   for (const [name, entry] of Object.entries(games)) {
-    collect2(problems, `/games/${esc(name)}`, game, entry);
+    collect3(problems, `/games/${esc(name)}`, game, entry);
   }
   crossReference(problems, games);
   return { config: cfg, problems };
 }
-function collect2(problems, prefix, schema, value) {
+function collect3(problems, prefix, schema, value) {
   const result = schema.safeParse(value);
   if (result.success)
     return;
   for (const issue of result.error.issues) {
     if (issue.code === "unrecognized_keys") {
       const hints = hintsFor(issue.message);
-      issue.keys.forEach((key2, i) => {
-        const problem2 = {
-          where: `${prefix}${pointer(issue.path)}/${esc(key2)}`,
-          message: `unknown key "${key2}"`
+      issue.keys.forEach((key, i) => {
+        const problem = {
+          where: `${prefix}${pointer(issue.path)}/${esc(key)}`,
+          message: `unknown key "${key}"`
         };
-        const hint2 = hints[i];
-        if (hint2 != null)
-          problem2.suggestion = `did you mean "${hint2}"?`;
-        problems.push(problem2);
+        const hint = hints[i];
+        if (hint != null)
+          problem.suggestion = `did you mean "${hint}"?`;
+        problems.push(problem);
       });
       continue;
     }
@@ -1612,6 +2009,7 @@ function valueAt(root_, path) {
   return current;
 }
 function crossReference(p, games) {
+  const containers = new Map;
   for (const [gameName, game_] of Object.entries(games)) {
     const where = `/games/${esc(gameName)}`;
     checkName(p, where, gameName, "game");
@@ -1627,7 +2025,7 @@ function crossReference(p, games) {
       if (!isObj(prof))
         continue;
       const parent = prof["extends"];
-      if (typeof parent === "string" && !Object.hasOwn(profiles, parent)) {
+      if (typeof parent === "string" && !resolves(profiles, parent)) {
         const prob = { where: `${w}/extends`, message: `extends unknown profile "${parent}"` };
         const hint = suggest(parent, names);
         if (hint)
@@ -1635,14 +2033,14 @@ function crossReference(p, games) {
         p.push(prob);
       }
       const alias = prof["alias"];
-      if (typeof alias === "string" && alias !== "modless" && !Object.hasOwn(profiles, alias)) {
+      if (typeof alias === "string" && !resolves(profiles, alias)) {
         const prob = { where: `${w}/alias`, message: `alias of unknown profile "${alias}"` };
         const hint = suggest(alias, [...names, "modless"]);
         if (hint)
           prob.suggestion = `did you mean "${hint}"?`;
         p.push(prob);
       }
-      if (typeof alias === "string" && alias === name) {
+      if (typeof alias === "string" && alias.toLowerCase() === name.toLowerCase()) {
         p.push({ where: `${w}/alias`, message: "a profile cannot alias itself" });
       }
       const aliases = prof["aliases"];
@@ -1664,10 +2062,81 @@ function crossReference(p, games) {
         }
       }
     }
+    checkCollisions(p, where, gameName, profiles, containers);
+  }
+}
+function resolves(profiles, name) {
+  if (name.toLowerCase() === "modless")
+    return true;
+  return profileKey({ profiles }, name) !== undefined;
+}
+function checkCollisions(p, where, gameName, profiles, containers) {
+  const names = new Map;
+  const aliasOwners = new Map;
+  const prefix = `${gameName.toLowerCase()}-`;
+  for (const [name, prof] of Object.entries(profiles)) {
+    const w = `${where}/profiles/${esc(name)}`;
+    const lower = name.toLowerCase();
+    const twin = names.get(lower);
+    if (twin !== undefined) {
+      p.push({
+        where: w,
+        message: `profile "${name}" differs from "${twin}" only in case, so both share one data directory`
+      });
+      continue;
+    }
+    names.set(lower, name);
+    const clash = containers.get(prefix + lower);
+    if (clash !== undefined) {
+      p.push({ where: w, message: `container name collides with ${clash}` });
+      continue;
+    }
+    containers.set(prefix + lower, w);
+    if (!isObj(prof))
+      continue;
+    const aliases = prof["aliases"];
+    if (Array.isArray(aliases)) {
+      for (const [i, entry] of aliases.entries()) {
+        if (typeof entry !== "string")
+          continue;
+        const owner = aliasOwners.get(entry.toLowerCase());
+        if (owner !== undefined) {
+          p.push({
+            where: `${w}/aliases/${i}`,
+            message: `alias "${entry}" is already declared by profile "${owner}"`
+          });
+          continue;
+        }
+        aliasOwners.set(entry.toLowerCase(), name);
+      }
+    }
+    const declared = prof["instances"];
+    for (const instance of instanceNames(profiles, name, prof)) {
+      const container = `${prefix}${lower}-${instance.toLowerCase()}`;
+      const at = isObj(declared) && Object.hasOwn(declared, instance) ? `${w}/instances/${esc(instance)}` : w;
+      const first = containers.get(container);
+      if (first !== undefined) {
+        p.push({
+          where: at,
+          message: `instance "${instance}" makes a container name that collides with ${first}`
+        });
+        continue;
+      }
+      containers.set(container, at);
+    }
+  }
+}
+function instanceNames(profiles, name, prof) {
+  try {
+    const resolved = resolveProfile({ profiles }, name).instances;
+    return isObj(resolved) ? Object.keys(resolved) : [];
+  } catch {
+    const declared = prof["instances"];
+    return isObj(declared) ? Object.keys(declared) : [];
   }
 }
 function checkName(p, where, name, kind) {
-  if (RESERVED_NAMES.includes(name)) {
+  if (RESERVED_NAMES.includes(name.toLowerCase())) {
     p.push({ where, message: `"${name}" is a reserved name and cannot be used as a ${kind} name` });
     return;
   }
@@ -1683,11 +2152,32 @@ function isObj(v) {
 }
 
 // src/config/load.ts
-function defaultConfigPath() {
-  const base = process.env["XDG_CONFIG_HOME"] ?? join5(homedir2(), ".config");
-  return join5(base, "gamecrate", "profiles.json");
+function globalConfigDir() {
+  const base = process.env["XDG_CONFIG_HOME"] ?? join6(homedir2(), ".config");
+  return join6(base, "gamecrate");
+}
+async function findGlobalConfig() {
+  return probe(globalConfigDir(), "profiles");
+}
+async function probe(dir, stem) {
+  const found = [];
+  for (const suffix of CONFIG_SUFFIXES) {
+    const file = join6(dir, `${stem}${suffix}`);
+    try {
+      await access(file);
+      found.push(file);
+    } catch (error) {
+      if (error.code !== "ENOENT")
+        throw error;
+    }
+  }
+  if (found.length > 1) {
+    throw new GamecrateError(`two configs in ${dir}`, Exit.Config, `${found.map((f) => `  ${basename4(f)}`).join(`
+`)}
+keep one`);
+  }
+  return found[0];
 }
-var PROJECT_CONFIG = ".gamecrate.yml";
 var projectName = z2.custom((v) => typeof v === "string" && NAME_PATTERN.test(v), "expected a name");
 var projectStr = z2.string({ error: "expected a string" });
 var projectBool = z2.boolean({ error: "expected true or false" });
@@ -1704,9 +2194,12 @@ var projectResolution = z2.string({ error: "expected dimensions like 1920x1080"
     ctx.issues.push({ code: "custom", message: error.message, input: ctx.value });
   }
 }).transform(parseResolution);
-var PROJECT_SCHEMA = z2.strictObject({
+var PROJECT_OBJECT = z2.strictObject({
   game: projectName.optional(),
-  profile: projectName.optional(),
+  defaultProfile: projectName.optional(),
+  profiles: z2.record(z2.string(), z2.unknown()).optional(),
+  settings: z2.record(z2.string(), z2.unknown()).optional(),
+  detach: projectBool.optional(),
   mods: projectList.optional(),
   without: projectList.optional(),
   only: projectList.optional(),
@@ -1735,17 +2228,27 @@ var PROJECT_SCHEMA = z2.strictObject({
   }).optional(),
   resolution: projectResolution.optional()
 }, { error: "expected an object" });
+var PROJECT_SCHEMA = PROJECT_OBJECT.check((ctx) => {
+  const { game, profiles, settings } = ctx.value;
+  if (game !== undefined)
+    return;
+  for (const [key, value] of [["profiles", profiles], ["settings", settings]]) {
+    if (value === undefined)
+      continue;
+    ctx.issues.push({
+      code: "custom",
+      path: [key],
+      message: "needs a top-level game: to say which game it belongs to",
+      input: ctx.value
+    });
+  }
+});
 async function findProjectConfig(start = process.cwd()) {
   let dir = resolve3(start);
   for (;; ) {
-    const file = join5(dir, PROJECT_CONFIG);
-    try {
-      await access(file);
+    const file = await probe(dir, ".gamecrate");
+    if (file !== undefined)
       return file;
-    } catch (error) {
-      if (error.code !== "ENOENT")
-        throw error;
-    }
     const parent = dirname2(dir);
     if (parent === dir)
       return;
@@ -1756,13 +2259,18 @@ async function loadProjectDefaults(start = process.cwd()) {
   const file = await findProjectConfig(start);
   if (file === undefined)
     return {};
-  let raw;
-  try {
-    raw = parseYaml(await readFile(file, "utf8"));
-  } catch (error) {
-    throw new GamecrateError(`project config is invalid: ${file}`, Exit.Config, error.message);
+  const text = await readFile2(file, "utf8");
+  const defaults = validateProjectDefaults(readConfigText(text, file), file);
+  const profiles = defaults.profiles;
+  if (profiles !== undefined) {
+    const order = orderedKeys(text, file, "profiles");
+    if (order.length !== Object.keys(profiles).length || order.some((key) => !Object.hasOwn(profiles, key))) {
+      throw new GamecrateError(`config is invalid: ${file}`, Exit.Config, "duplicate profiles key");
+    }
+    defaults.profileOrder = order;
   }
-  return validateProjectDefaults(raw, file);
+  defaults.configPath = file;
+  return defaults;
 }
 function validateProjectDefaults(raw, file) {
   if (raw === null)
@@ -1782,18 +2290,9 @@ function validateProjectDefaults(raw, file) {
   throw new GamecrateError(`project config is invalid: ${file}`, Exit.Config, problems.join(`
 `));
 }
-async function loadConfig(path) {
-  const file = path ?? defaultConfigPath();
-  let user;
-  try {
-    user = parseJsonc(await readFile(file, "utf8"));
-  } catch (err) {
-    if (err instanceof GamecrateError) {
-      throw new GamecrateError(`${err.message}: ${file}`, err.code, err.detail);
-    }
-    if (err.code !== "ENOENT")
-      throw err;
-  }
+async function loadConfig(path, project) {
+  const file = path ?? await findGlobalConfig() ?? join6(globalConfigDir(), "profiles.yml");
+  const user = await readConfigFile(file);
   const specs = isObj(user) && user["plugins"] !== undefined ? user["plugins"] : [];
   if (!Array.isArray(specs) || specs.some((s) => typeof s !== "string")) {
     throw new GamecrateError(`config is invalid: ${file}`, Exit.Config, "  /plugins: expected an array of strings");
@@ -1804,29 +2303,57 @@ async function loadConfig(path) {
     defaults: { settings: structuredClone(DEFAULT_SETTINGS) },
     games: Object.fromEntries([...plugins].map(([name, plugin]) => [name, structuredClone(plugin.defaults)]))
   };
-  const { config, problems } = validateConfig(user === undefined ? base : deepMerge(base, user));
+  const merged = user === undefined ? base : deepMerge(base, user);
+  const spliced = applyProject(merged, project);
+  const { config, problems } = validateConfig(spliced);
   if (problems.length > 0) {
     const detail = problems.map((p) => {
       const hint = p.suggestion ? ` (${p.suggestion})` : "";
-      return `  ${p.where || "/"}: ${p.message}${hint}${origin(p.where, user, plugins)}`;
+      return `  ${p.where || "/"}: ${p.message}${hint}${origin(p.where, user, plugins, project)}`;
     }).join(`
 `);
-    const merged = plugins.size === 0 ? "" : ` (merged with defaults from: ${[...plugins.keys()].join(", ")})`;
-    throw new GamecrateError(`config is invalid: ${file}${merged}`, Exit.Config, detail);
+    const from = plugins.size === 0 ? "" : ` (merged with defaults from: ${[...plugins.keys()].join(", ")})`;
+    throw new GamecrateError(`config is invalid: ${file}${from}`, Exit.Config, detail);
   }
   return { config: expandPaths(config), plugins };
 }
-function origin(where, user, plugins) {
+function applyProject(config, project) {
+  if (project === undefined)
+    return config;
+  const game = project.game;
+  if (game === undefined)
+    return config;
+  if (project.profiles === undefined && project.settings === undefined)
+    return config;
+  const existing = own(config.games, game);
+  if (existing === undefined) {
+    throw new GamecrateError(`the project config names game "${game}", which is not configured`, Exit.Config, `known games: ${Object.keys(config.games).join(", ") || "none"}`);
+  }
+  const target = {
+    ...existing,
+    profiles: { ...existing.profiles, ...project.profiles }
+  };
+  config.games[game] = target;
+  if (project.settings !== undefined) {
+    target.settings = deepMerge(target.settings ?? {}, project.settings);
+  }
+  return config;
+}
+function origin(where, user, plugins, project) {
   if (!where.startsWith("/"))
     return "";
   const segments = where.slice(1).split("/").map((s) => s.replace(/~1/g, "/").replace(/~0/g, "~"));
+  const [section, name, sub, ...rest] = segments;
+  const repoGame = project?.game;
+  if (repoGame !== undefined && section === "games" && name === repoGame && (sub === "profiles" || sub === "settings") && valueAt2(sub === "profiles" ? project?.profiles : project?.settings, rest) !== undefined) {
+    return "  <- from the .gamecrate project config, not this file";
+  }
   if (valueAt2(user, segments) !== undefined)
     return "";
-  const [section, name, ...rest] = segments;
   const plugin = section === "games" && name !== undefined ? plugins.get(name) : undefined;
   if (plugin === undefined)
     return "  <- not in this file";
-  return valueAt2(plugin.defaults, rest) === undefined ? `  <- not in this file, and the ${name} plugin's defaults do not supply it` : `  <- from the ${name} plugin's defaults, not this file`;
+  return valueAt2(plugin.defaults, [sub, ...rest].filter((s) => s !== undefined)) === undefined ? `  <- not in this file, and the ${name} plugin's defaults do not supply it` : `  <- from the ${name} plugin's defaults, not this file`;
 }
 function valueAt2(value, segments) {
   let current = value;
@@ -1840,31 +2367,31 @@ function valueAt2(value, segments) {
   }
   return current;
 }
-function resolveSettings(root2, game2, profile2, ...overrides) {
+function resolveSettings(root, game, profile, ...overrides) {
   let out = structuredClone(DEFAULT_SETTINGS);
-  for (const layer of [root2.defaults?.settings, game2.settings, profile2.settings, ...overrides]) {
+  for (const layer of [root.defaults?.settings, game.settings, profile.settings, ...overrides]) {
     if (layer)
       out = deepMerge(out, layer, true);
   }
   return out;
 }
-function resolveProfile(game2, name) {
-  return resolveNamed(game2, name, []);
+function resolveProfile(game, name) {
+  return resolveNamed(game, name, []);
 }
-function resolveNamed(game2, name, seen) {
+function resolveNamed(game, name, seen) {
   if (name.toLowerCase() === "modless")
     return { mods: [], exclude: [], includeBase: false };
-  const key = profileKey(game2, name);
+  const key = profileKey(game, name);
   if (key === undefined) {
-    throw new GamecrateError(`unknown profile "${name}"`, Exit.Resolution, `known profiles: ${Object.keys(game2.profiles).join(", ") || "(none)"}, modless`);
+    throw new GamecrateError(`unknown profile "${name}"`, Exit.Resolution, `known profiles: ${Object.keys(game.profiles).join(", ") || "(none)"}, modless`);
   }
   if (seen.includes(key)) {
     throw new GamecrateError(`profile "${key}" inherits from itself`, Exit.Config, [...seen, key].join(" -> "));
   }
-  const self = own(game2.profiles, key);
+  const self = own(game.profiles, key);
   if (self.alias !== undefined)
-    return resolveNamed(game2, self.alias, [...seen, key]);
-  const parent = self.extends !== undefined ? resolveNamed(game2, self.extends, [...seen, key]) : {};
+    return resolveNamed(game, self.alias, [...seen, key]);
+  const parent = self.extends !== undefined ? resolveNamed(game, self.extends, [...seen, key]) : {};
   const exclude = [...parent.exclude ?? [], ...self.exclude ?? []];
   const out = {
     mods: subtract([...parent.mods ?? [], ...self.mods ?? []], exclude),
@@ -1882,39 +2409,39 @@ function resolveNamed(game2, name, seen) {
     out.autoDependencies = auto;
   return out;
 }
-function canonicalProfile(game2, name) {
+function canonicalProfile(game, name) {
   if (name.toLowerCase() === "modless")
     return "modless";
   const seen = [];
   let current = name;
   for (;; ) {
-    const key = profileKey(game2, current);
+    const key = profileKey(game, current);
     if (key === undefined || seen.includes(key))
       return key ?? current;
-    const next = own(game2.profiles, key)?.alias;
+    const next = own(game.profiles, key)?.alias;
     if (next === undefined)
       return key;
     seen.push(key);
     current = next;
   }
 }
-function profileDataDir(root2, game2, profile2) {
-  return resolve3(expandHome(root2.dataRoot), game2, canonicalProfile(own(root2.games, game2), profile2));
+function profileDataDir(root, game, profile) {
+  return resolve3(expandHome(root.dataRoot), game, canonicalProfile(own(root.games, game), profile));
 }
-async function profileDirs(root2, game2, profile2) {
-  if (profile2 !== undefined)
-    return [profileDataDir(root2, game2, profile2)];
-  const dir = join5(expandHome(root2.dataRoot), game2);
-  return (await readdir2(dir).catch(() => [])).map((name) => join5(dir, name));
+async function profileDirs(root, game, profile) {
+  if (profile !== undefined)
+    return [profileDataDir(root, game, profile)];
+  const dir = join6(expandHome(root.dataRoot), game);
+  return (await readdir3(dir).catch(() => [])).map((name) => join6(dir, name));
 }
-function profileKey(game2, name) {
-  if (Object.hasOwn(game2.profiles, name))
+function profileKey(game, name) {
+  if (Object.hasOwn(game.profiles, name))
     return name;
   const lower = name.toLowerCase();
-  const direct = Object.keys(game2.profiles).find((k) => k.toLowerCase() === lower);
+  const direct = Object.keys(game.profiles).find((k) => k.toLowerCase() === lower);
   if (direct !== undefined)
     return direct;
-  return Object.keys(game2.profiles).find((k) => (own(game2.profiles, k)?.aliases ?? []).some((a) => a.toLowerCase() === lower));
+  return Object.keys(game.profiles).find((k) => (own(game.profiles, k)?.aliases ?? []).some((a) => typeof a === "string" && a.toLowerCase() === lower));
 }
 function subtract(mods, exclude) {
   if (exclude.length === 0)
@@ -1955,16 +2482,16 @@ function deepMerge(base, over, concatArrays = false) {
 }
 function expandPaths(config) {
   config.dataRoot = expandHome(config.dataRoot);
-  for (const game2 of Object.values(config.games)) {
-    if (game2.gameFiles.host !== undefined)
-      game2.gameFiles.host = expandHome(game2.gameFiles.host);
-    if (game2.image.context !== undefined)
-      game2.image.context = expandHome(game2.image.context);
-    if (game2.workshopRoot !== null)
-      game2.workshopRoot = expandHome(game2.workshopRoot);
-    for (const root2 of game2.scanRoots)
-      root2.path = expandHome(root2.path);
-    for (const entry of Object.values(game2.library ?? {})) {
+  for (const game of Object.values(config.games)) {
+    if (game.gameFiles.host !== undefined)
+      game.gameFiles.host = expandHome(game.gameFiles.host);
+    if (game.image.context !== undefined)
+      game.image.context = expandHome(game.image.context);
+    if (game.workshopRoot !== null)
+      game.workshopRoot = expandHome(game.workshopRoot);
+    for (const root of game.scanRoots)
+      root.path = expandHome(root.path);
+    for (const entry of Object.values(game.library ?? {})) {
       if (entry.path !== undefined)
         entry.path = expandHome(entry.path);
     }
@@ -1974,183 +2501,35 @@ function expandPaths(config) {
 function expandHome(p) {
   if (p === "~")
     return homedir2();
-  return p.startsWith("~/") ? join5(homedir2(), p.slice(2)) : p;
-}
-
-// src/docker/identity.ts
-import { userInfo } from "node:os";
-function resolveIdentity(useRoot) {
-  if (useRoot)
-    return { uid: 0, gid: 0, home: "/root", user: "root" };
-  const uid = process.getuid?.() ?? 0;
-  const gid = process.getgid?.() ?? 0;
-  return { uid, gid, home: "/tmp/home", user: hostUserName(uid) };
-}
-function hostUserName(uid) {
-  try {
-    const name = userInfo().username;
-    if (name)
-      return name;
-  } catch {}
-  return process.env.USER ?? process.env.LOGNAME ?? `uid-${uid}`;
-}
-
-// src/docker/preflight.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "node:fs";
-import { homedir as homedir3 } from "node:os";
-import { basename as basename3, join as join7 } from "node:path";
-
-// src/docker/run.ts
-import { spawn } from "node:child_process";
-import { createWriteStream, mkdirSync as mkdirSync2 } from "node:fs";
-import { open, readdir as readdir3, stat as stat2 } from "node:fs/promises";
-import { join as join6 } from "node:path";
-import { setTimeout as sleep } from "node:timers/promises";
-import { TextDecoder } from "node:util";
-function spawnArgv(argv, stdio) {
-  return spawn(argv[0], argv.slice(1), { stdio });
-}
-function exited(proc) {
-  return new Promise((resolve4, reject) => {
-    proc.once("error", reject);
-    proc.once("close", (code) => resolve4(code ?? 1));
-  });
-}
-async function collect3(stream) {
-  const chunks = [];
-  for await (const chunk of stream)
-    chunks.push(chunk);
-  return Buffer.concat(chunks).toString("utf8");
-}
-async function capture(argv) {
-  try {
-    const proc = spawnArgv(argv, ["ignore", "pipe", "pipe"]);
-    const [stdout, stderr, code] = await Promise.all([
-      collect3(proc.stdout),
-      collect3(proc.stderr),
-      exited(proc)
-    ]);
-    return { code, stdout, stderr };
-  } catch (error) {
-    return { code: 127, stdout: "", stderr: error instanceof Error ? error.message : String(error) };
-  }
-}
-var STDOUT_LOG = "stdout.log";
-var MARKER_POLL_MS = 200;
-async function runContainer(spec, opts) {
-  const stopTimeout = opts.stopTimeoutSeconds ?? 10;
-  mkdirSync2(opts.logDir, { recursive: true });
-  const sink = createWriteStream(join6(opts.logDir, STDOUT_LOG));
-  const proc = spawnArgv(["docker", ...toDockerArgs(spec)], ["inherit", "pipe", "pipe"]);
-  let interrupted = false;
-  const onSignal = () => {
-    if (interrupted)
-      return;
-    interrupted = true;
-    stopContainer(spec.name, stopTimeout);
-  };
-  process.on("SIGINT", onSignal);
-  process.on("SIGTERM", onSignal);
-  const code = exited(proc);
-  try {
-    await Promise.all([
-      tee(proc.stdout, sink, process.stdout),
-      tee(proc.stderr, sink, process.stderr)
-    ]);
-    const status2 = await code;
-    return interrupted ? Exit.Interrupted : status2;
-  } finally {
-    process.off("SIGINT", onSignal);
-    process.off("SIGTERM", onSignal);
-    await new Promise((resolve4) => sink.end(resolve4));
-  }
-}
-async function stopContainer(name, timeoutSeconds) {
-  const proc = spawnArgv(["docker", "stop", "--timeout", String(timeoutSeconds), name], "ignore");
-  await exited(proc).catch(() => {});
-}
-async function waitForMarker(sources, marker, timeoutSeconds) {
-  const deadline = Date.now() + timeoutSeconds * 1000;
-  const carry = Math.max(marker.length - 1, 0);
-  const seen = new Map;
-  const startedAt = Date.now();
-  while (true) {
-    for (const path of await expandSources(sources)) {
-      let state = seen.get(path);
-      if (state === undefined) {
-        state = { offset: await staleSize(path, startedAt), tail: "", decoder: new TextDecoder };
-        seen.set(path, state);
-      }
-      if (await scan(path, state, marker, carry))
-        return true;
-    }
-    if (Date.now() >= deadline)
-      return false;
-    await sleep(Math.min(MARKER_POLL_MS, Math.max(deadline - Date.now(), 0)));
-  }
-}
-async function staleSize(path, startedAt) {
-  return stat2(path).then((info) => info.mtimeMs < startedAt ? info.size : 0, () => 0);
-}
-async function scan(path, state, marker, carry) {
-  const handle = await open(path, "r").catch(() => null);
-  if (handle === null)
-    return false;
-  try {
-    const { size } = await handle.stat();
-    if (size < state.offset) {
-      state.offset = 0;
-      state.tail = "";
-      state.decoder = new TextDecoder;
-    }
-    if (size <= state.offset)
-      return false;
-    const buffer = Buffer.alloc(size - state.offset);
-    const { bytesRead } = await handle.read(buffer, 0, buffer.length, state.offset);
-    state.offset += bytesRead;
-    const text = state.tail + state.decoder.decode(buffer.subarray(0, bytesRead), { stream: true });
-    if (text.includes(marker))
-      return true;
-    state.tail = carry > 0 ? text.slice(-carry) : "";
-    return false;
-  } catch {
-    return false;
-  } finally {
-    await handle.close().catch(() => {});
-  }
-}
-async function expandSources(sources) {
-  const out = [];
-  for (const source of sources) {
-    const info = await stat2(source).catch(() => null);
-    if (info === null) {
-      out.push(source);
-      continue;
-    }
-    if (!info.isDirectory()) {
-      out.push(source);
-      continue;
-    }
-    const entries = await readdir3(source).catch(() => []);
-    for (const entry of entries) {
-      if (entry.toLowerCase().endsWith(".log"))
-        out.push(join6(source, entry));
-    }
-  }
-  return out;
+  return p.startsWith("~/") ? join6(homedir2(), p.slice(2)) : p;
 }
-async function tee(stream, sink, mirror) {
-  for await (const chunk of stream) {
-    mirror.write(chunk);
-    sink.write(chunk);
-  }
+
+// src/docker/identity.ts
+import { userInfo } from "node:os";
+function resolveIdentity(useRoot) {
+  if (useRoot)
+    return { uid: 0, gid: 0, home: "/root", user: "root" };
+  const uid = process.getuid?.() ?? 0;
+  const gid = process.getgid?.() ?? 0;
+  return { uid, gid, home: "/tmp/home", user: hostUserName(uid) };
+}
+function hostUserName(uid) {
+  try {
+    const name = userInfo().username;
+    if (name)
+      return name;
+  } catch {}
+  return process.env.USER ?? process.env.LOGNAME ?? `uid-${uid}`;
 }
 
 // src/docker/preflight.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { basename as basename5, join as join7 } from "node:path";
 var CDI_SPEC = "/etc/cdi/nvidia.yaml";
 async function preflight(plan) {
   const problems = [];
-  const game2 = plan.gameConfig;
+  const game = plan.gameConfig;
   const dockerOk = await checkDocker(problems);
   if (dockerOk) {
     await checkImage(plan, problems);
@@ -2161,7 +2540,7 @@ async function preflight(plan) {
   checkBindSources(plan, problems);
   if (plan.mode === "headed")
     checkDisplay(plan, problems);
-  if (game2.gameFiles.source === "image" && game2.image.acquire === "build" && !game2.image.context) {
+  if (game.gameFiles.source === "image" && game.image.acquire === "build" && !game.image.context) {
     problems.push({
       where: `/games/${plan.game}/image/context`,
       message: 'image.acquire is "build" but no build context is configured'
@@ -2180,7 +2559,7 @@ async function checkDocker(problems) {
   });
   return false;
 }
-async function checkImageRunnable(ref, where, game2, problems) {
+async function checkImageRunnable(ref, where, game, problems) {
   const run = await capture(["docker", "run", "--rm", "--entrypoint", "/bin/true", ref]);
   if (run.code === 0)
     return;
@@ -2189,7 +2568,7 @@ async function checkImageRunnable(ref, where, game2, problems) {
   problems.push({
     where,
     message: corrupt ? `image ${ref} is present but unrunnable; its layers are missing from the content store` : `image ${ref} is present but failed to start: ${err || `exit ${run.code}`}`,
-    suggestion: corrupt ? `docker image rm ${ref} && docker builder prune -f, then gamecrate build ${game2}` : undefined
+    suggestion: corrupt ? `docker image rm ${ref} && docker builder prune -f, then gamecrate build ${game}` : undefined
   });
 }
 async function checkImage(plan, problems) {
@@ -2282,11 +2661,11 @@ function checkGameDir(plan, problems) {
     problems.push({ where, message: `game directory does not exist: ${files.host}` });
     return;
   }
-  const executable = join7(files.host, basename3(plan.gameConfig.executable));
+  const executable = join7(files.host, basename5(plan.gameConfig.executable));
   if (!existsSync3(executable)) {
     problems.push({
       where,
-      message: `${files.host} does not contain ${basename3(plan.gameConfig.executable)}`,
+      message: `${files.host} does not contain ${basename5(plan.gameConfig.executable)}`,
       suggestion: "point gameFiles.host at the install directory, not its parent"
     });
   }
@@ -2347,18 +2726,43 @@ function message(error) {
 }
 
 // src/docker/window.ts
-import { basename as basename4 } from "node:path";
+import { readFileSync as readFileSync3 } from "node:fs";
+import { basename as basename6 } from "node:path";
 import { setTimeout as sleep2 } from "node:timers/promises";
 var WAIT_MS = 180000;
 var POLL_MS = 500;
+function newMatches(now, seen, executable) {
+  const wanted = basename6(executable).toLowerCase();
+  return now.filter((w) => !seen.has(w.id) && w.wmClass.toLowerCase().includes(wanted));
+}
+function parseWindowPid(stdout) {
+  const match = /_NET_WM_PID\(CARDINAL\)\s*=\s*(\d+)/.exec(stdout);
+  const pid = Number(match?.[1]);
+  return Number.isSafeInteger(pid) && pid > 0 ? pid : undefined;
+}
+function isPeerClaim(pid, self) {
+  if (pid === self)
+    return false;
+  try {
+    const argv = readFileSync3(`/proc/${pid}/cmdline`, "utf8").split("\x00");
+    return argv.some((arg) => basename6(arg).startsWith("gamecrate"));
+  } catch {
+    return false;
+  }
+}
+async function claimedByPeer(id) {
+  const { stdout } = await capture(["xprop", "-id", id, "_NET_WM_PID"]);
+  const pid = parseWindowPid(stdout);
+  return pid !== undefined && isPeerClaim(pid, process.pid);
+}
 async function toplevels() {
   const { code, stdout } = await capture(["wmctrl", "-lx"]);
   if (code === 127)
     return null;
   const found = [];
-  for (const line2 of stdout.split(`
+  for (const line of stdout.split(`
 `)) {
-    const [id, , wmClass] = line2.trim().split(/\s+/);
+    const [id, , wmClass] = line.trim().split(/\s+/);
     if (id !== undefined && wmClass !== undefined)
       found.push({ id, wmClass });
   }
@@ -2371,7 +2775,6 @@ async function adoptNewWindow(opts) {
     return { stop: () => {} };
   }
   const seen = new Set(before.map((w) => w.id));
-  const wanted = basename4(opts.executable).toLowerCase();
   let stopped = false;
   (async () => {
     const deadline = Date.now() + WAIT_MS;
@@ -2379,15 +2782,18 @@ async function adoptNewWindow(opts) {
       await sleep2(POLL_MS);
       if (stopped)
         return;
-      const now = await toplevels() ?? [];
-      const match = now.find((w) => !seen.has(w.id) && w.wmClass.toLowerCase().includes(wanted));
-      if (match === undefined)
-        continue;
-      await capture(["wmctrl", "-i", "-r", match.id, "-N", opts.title]);
-      await adopt(match.id, opts);
-      if (opts.stripDelete)
-        await watchForClose(match.id, () => stopped, opts.onClosed);
-      return;
+      for (const match of newMatches(await toplevels() ?? [], seen, opts.executable)) {
+        if (stopped)
+          return;
+        if (await claimedByPeer(match.id))
+          continue;
+        if (!await adopt(match.id, opts))
+          continue;
+        await capture(["wmctrl", "-i", "-r", match.id, "-N", opts.title]);
+        if (opts.stripDelete)
+          await watchForClose(match.id, () => stopped, opts.onClosed);
+        return;
+      }
     }
   })();
   return { stop: () => void (stopped = true) };
@@ -2412,15 +2818,19 @@ async function adopt(id, opts) {
   const protocols = await capture(["xprop", "-id", id, "WM_PROTOCOLS"]);
   if (protocols.code === 127) {
     warn("xprop is not installed, so nothing out here can fix the window's close button");
-    return;
+    return true;
   }
-  await claimPid(id);
+  if (!await claimPid(id))
+    return false;
   if (opts.stripDelete)
     await dropDeleteProtocol(id, parseAtoms(protocols.stdout));
+  return true;
 }
 async function claimPid(id) {
   const pid = String(process.pid);
   await capture(["xprop", "-id", id, "-f", "_NET_WM_PID", "32c", "-set", "_NET_WM_PID", pid]);
+  const readBack = await capture(["xprop", "-id", id, "_NET_WM_PID"]);
+  return parseWindowPid(readBack.stdout) === process.pid;
 }
 async function dropDeleteProtocol(id, atoms) {
   if (!atoms.includes("WM_DELETE_WINDOW"))
@@ -2449,33 +2859,33 @@ function parseAtoms(stdout) {
 }
 
 // src/launch/generate.ts
-import { mkdir, readdir as readdir4, readFile as readFile2, writeFile } from "node:fs/promises";
+import { mkdir, readdir as readdir4, readFile as readFile3, writeFile } from "node:fs/promises";
 import { dirname as dirname3, join as join8 } from "node:path";
-async function readInstallVersion(game2, plugin) {
-  const host = game2.gameFiles.host;
-  if (game2.gameFiles.source !== "mount" || host === undefined)
+async function readInstallVersion(game, plugin) {
+  const host = game.gameFiles.host;
+  if (game.gameFiles.source !== "mount" || host === undefined)
     return null;
   let raw;
   try {
-    raw = await readFile2(join8(expandHome(host), "Version.txt"), "utf8");
+    raw = await readFile3(join8(expandHome(host), "Version.txt"), "utf8");
   } catch {
     return null;
   }
   return plugin.parseVersion(raw.replace(/^/, "").trim());
 }
-async function readKnownExpansions(game2, plugin, warnings) {
-  if (game2.dlc.length === 0)
+async function readKnownExpansions(game, plugin, warnings) {
+  if (game.dlc.length === 0)
     return [];
-  const host = game2.gameFiles.host;
-  if (game2.gameFiles.source !== "mount" || host === undefined)
-    return [...game2.dlc];
+  const host = game.gameFiles.host;
+  if (game.gameFiles.source !== "mount" || host === undefined)
+    return [...game.dlc];
   const dataDir = join8(expandHome(host), "Data");
   let entries;
   try {
     entries = await readdir4(dataDir, { withFileTypes: true });
   } catch {
     warnings.push(`could not read ${dataDir}; falling back to the configured dlc list`);
-    return [...game2.dlc];
+    return [...game.dlc];
   }
   const found = [];
   for (const entry of entries) {
@@ -2483,14 +2893,14 @@ async function readKnownExpansions(game2, plugin, warnings) {
       continue;
     let id = null;
     try {
-      id = plugin.parseManifest(await readFile2(join8(dataDir, entry.name, game2.manifest.file), "utf8"))?.packageId ?? null;
+      id = plugin.parseManifest(await readFile3(join8(dataDir, entry.name, game.manifest.file), "utf8"))?.packageId ?? null;
     } catch {
       continue;
     }
-    if (id !== null && id.toLowerCase() !== game2.core.toLowerCase())
+    if (id !== null && id.toLowerCase() !== game.core.toLowerCase())
       found.push(id);
   }
-  const order = game2.dlc.map((id) => id.toLowerCase());
+  const order = game.dlc.map((id) => id.toLowerCase());
   return found.sort((a, b) => {
     const ai = order.indexOf(a.toLowerCase());
     const bi = order.indexOf(b.toLowerCase());
@@ -2498,14 +2908,14 @@ async function readKnownExpansions(game2, plugin, warnings) {
   });
 }
 async function generateModsConfig(plan) {
-  const game2 = plan.gameConfig;
-  const target = join8(plan.dataDirHost, game2.modsConfig.file);
+  const game = plan.gameConfig;
+  const target = join8(plan.dataDirHost, game.modsConfig.file);
   await mkdir(dirname3(target), { recursive: true });
-  const installed = await readInstallVersion(game2, plan.plugin);
+  const installed = await readInstallVersion(game, plan.plugin);
   if (installed === null) {
     plan.warnings.push(`could not read Version.txt for ${plan.game}; ModsConfig version may be rejected`);
   }
-  const declared = new Map([game2.core, ...game2.dlc].map((id) => [id.toLowerCase(), id]));
+  const declared = new Map([game.core, ...game.dlc].map((id) => [id.toLowerCase(), id]));
   const seen = new Set;
   const activeMods = [];
   for (const mod of plan.mods) {
@@ -2515,7 +2925,7 @@ async function generateModsConfig(plan) {
     seen.add(key);
     activeMods.push(key);
   }
-  const knownExpansions = (await readKnownExpansions(game2, plan.plugin, plan.warnings)).map((id) => declared.get(id.toLowerCase()) ?? id);
+  const knownExpansions = (await readKnownExpansions(game, plan.plugin, plan.warnings)).map((id) => declared.get(id.toLowerCase()) ?? id);
   await writeFile(target, fromPlugin(target, () => plan.plugin.renderModsConfig({
     version: installed?.version ?? "",
     buildNumber: installed?.buildNumber ?? -1,
@@ -2536,16 +2946,16 @@ function fromPlugin(target, render) {
   }
 }
 function ownedPrefs(plan) {
-  const { settings: settings2 } = plan;
-  const bool2 = (value) => value ? "True" : "False";
+  const { settings } = plan;
+  const bool = (value) => value ? "True" : "False";
   const owned = {
-    screenWidth: String(settings2.width),
-    screenHeight: String(settings2.height),
-    devMode: bool2(settings2.devMode),
-    runInBackground: bool2(settings2.runInBackground),
+    screenWidth: String(settings.width),
+    screenHeight: String(settings.height),
+    devMode: bool(settings.devMode),
+    runInBackground: bool(settings.runInBackground),
     ...plan.plugin.windowedPrefs
   };
-  Object.assign(owned, settings2.prefsExtra ?? {});
+  Object.assign(owned, settings.prefsExtra ?? {});
   owned.resetModsConfigOnCrash = "False";
   return owned;
 }
@@ -2554,7 +2964,7 @@ async function mergePrefs(plan) {
   await mkdir(dirname3(target), { recursive: true });
   let existing = null;
   try {
-    existing = await readFile2(target, "utf8");
+    existing = await readFile3(target, "utf8");
   } catch (error) {
     if (error.code !== "ENOENT")
       throw error;
@@ -2564,8 +2974,8 @@ async function mergePrefs(plan) {
 }
 
 // src/launch/prepare.ts
-import { existsSync as existsSync4 } from "node:fs";
-import { open as open2, readdir as readdir5, readFile as readFile3, unlink, writeFile as writeFile2 } from "node:fs/promises";
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "node:fs";
+import { open as open2, readdir as readdir5, readFile as readFile4, unlink, writeFile as writeFile2 } from "node:fs/promises";
 import { join as join9 } from "node:path";
 import { setTimeout as sleep3 } from "node:timers/promises";
 async function inherit(argv, stdin) {
@@ -2594,12 +3004,12 @@ async function imageLabel(ref, label) {
     return null;
   return value;
 }
-async function acquireImage(game2, config, pull) {
+async function acquireImage(game, config, pull) {
   const { image } = config;
   const present = await imageDigest(image.ref) !== null;
   if (image.acquire === "build") {
     if (image.context === undefined) {
-      throw new GamecrateError(`${game2} has image.acquire "build" but no context`, Exit.Config);
+      throw new GamecrateError(`${game} has image.acquire "build" but no context`, Exit.Config);
     }
     if (present && pull !== "always")
       return;
@@ -2672,10 +3082,10 @@ async function buildTarget(dir) {
   const csproj = entries.find((e) => e.endsWith(".csproj"));
   return csproj ? join9(dir, csproj) : null;
 }
-async function buildLocalMods(plan, policy2) {
-  if (policy2 === "never")
+async function buildLocalMods(plan, policy) {
+  if (policy === "never")
     return;
-  const wanted = plan.mods.filter((m) => m.kind === "local" && (policy2 === "always" || m.stale === true));
+  const wanted = plan.mods.filter((m) => m.kind === "local" && (policy === "always" || m.stale === true));
   if (wanted.length === 0)
     return;
   for (const mod of wanted) {
@@ -2690,7 +3100,7 @@ async function buildLocalMods(plan, policy2) {
     delete mod.staleReport;
   }
 }
-async function takeLock(plan) {
+async function clearLock(plan) {
   const path = lockPath(plan);
   const what = plan.instance === undefined ? plan.profile : `${plan.profile} (${plan.instance})`;
   const name = containerName(plan);
@@ -2699,66 +3109,150 @@ async function takeLock(plan) {
     throw new GamecrateError(`${plan.game} ${what} is already running (container ${name})`, Exit.Refused, `stop it with: docker stop ${name}
 or relaunch with --replace`);
   }
-  if (existsSync4(path)) {
-    const holder = await readFile3(path, "utf8").catch(() => "");
-    const pid = Number(holder.split(`
-`)[0]);
-    const alive = Number.isInteger(pid) && pid > 0 && isRunning(pid);
-    if (alive) {
-      throw new GamecrateError(`${plan.game} ${what} is already running (pid ${pid})`, Exit.Refused, `if that is wrong, delete ${path}
+  const held = await readLock(path);
+  if (held !== undefined && isRunning(held.pid, held.startedAt)) {
+    throw new GamecrateError(`${plan.game} ${what} is already running (pid ${held.pid})`, Exit.Refused, `if that is wrong, delete ${path}
 or relaunch with --replace`);
-    }
-    await unlink(path).catch(() => {});
-  }
-  const handle = await open2(path, "wx").catch(() => null);
-  if (handle === null) {
-    throw new GamecrateError(`could not take the launch lock at ${path}`, Exit.Environment);
   }
-  await handle.writeFile(`${process.pid}
-${new Date().toISOString()}
-`);
-  await handle.close();
+  if (existsSync4(path))
+    await unlink(path).catch(() => {});
+}
+async function unlinkHeld(path, pid, startedAt) {
+  const held = await readLock(path);
+  if (held === undefined)
+    return;
+  if (held.pid !== pid)
+    return;
+  if (startedAt !== undefined && held.startedAt !== startedAt)
+    return;
+  await unlink(path).catch(() => {});
+}
+function heldLock(plan) {
+  const path = lockPath(plan);
   return {
     release: async () => {
-      await unlink(path).catch(() => {});
+      await unlinkHeld(path, process.pid);
     }
   };
 }
+async function takeLock(plan) {
+  await clearLock(plan);
+  await writeLock(plan, {
+    pid: process.pid,
+    container: containerName(plan),
+    game: plan.game,
+    profile: plan.profile,
+    ...plan.instance === undefined ? {} : { instance: plan.instance },
+    detached: false,
+    mode: plan.mode
+  });
+  return heldLock(plan);
+}
 function lockPath(plan) {
   return join9(plan.instanceDir, ".gamecrate", "lock");
 }
-var RELEASE_WAIT_MS = 1e4;
+async function readLock(path) {
+  const text = await readFile4(path, "utf8").catch(() => {
+    return;
+  });
+  if (text === undefined)
+    return;
+  try {
+    const value = JSON.parse(text);
+    return Number.isInteger(value?.pid) && value.pid > 0 ? value : undefined;
+  } catch {
+    return;
+  }
+}
+async function writeLock(plan, record) {
+  const path = lockPath(plan);
+  const handle = await open2(path, "wx").catch(() => null);
+  if (handle === null) {
+    throw new GamecrateError(`could not take the launch lock at ${path}`, Exit.Environment);
+  }
+  await handle.writeFile(JSON.stringify({ ...record, startedAt: new Date().toISOString() }));
+  await handle.close();
+}
 var RELEASE_POLL_MS = 100;
-var REPLACE_STOP_TIMEOUT_SECONDS = 10;
+var DRAIN_ALLOWANCE_MS = 1e4;
+var STOP_RELEASE_WAIT_MS = STOP_TIMEOUT_SECONDS * 1000 + DRAIN_ALLOWANCE_MS;
+async function stopRun(record, lockFile) {
+  let signalled = false;
+  if (isRunning(record.pid, record.startedAt)) {
+    try {
+      process.kill(record.pid, "SIGTERM");
+      signalled = true;
+    } catch {}
+  }
+  if (!signalled)
+    await stopContainer(record.container, STOP_TIMEOUT_SECONDS);
+  const deadline = Date.now() + STOP_RELEASE_WAIT_MS;
+  while (existsSync4(lockFile)) {
+    const held = await readLock(lockFile);
+    if (held === undefined)
+      break;
+    if (!isRunning(held.pid, held.startedAt)) {
+      await unlinkHeld(lockFile, record.pid, record.startedAt);
+      break;
+    }
+    if (Date.now() >= deadline)
+      return "held";
+    await sleep3(RELEASE_POLL_MS);
+  }
+  return signalled ? "signalled" : "orphaned";
+}
 async function replacePrevious(plan) {
   const name = containerName(plan);
   const path = lockPath(plan);
   const up = await capture(["docker", "ps", "--quiet", "--filter", `name=^${name}$`]);
   const running = up.stdout.trim().length > 0;
-  if (!running && !existsSync4(path))
+  const held = await readLock(path);
+  if (!running && held === undefined && !existsSync4(path))
     return;
+  if (held !== undefined) {
+    status(`stopping ${held.container}`);
+    await stopRun(held, path);
+    return;
+  }
   if (running) {
     status(`stopping ${name}`);
-    await stopContainer(name, REPLACE_STOP_TIMEOUT_SECONDS);
-  }
-  const deadline = Date.now() + RELEASE_WAIT_MS;
-  while (existsSync4(path) && Date.now() < deadline) {
-    const holder = await readFile3(path, "utf8").catch(() => "");
-    const pid = Number(holder.split(`
-`)[0]);
-    if (!Number.isInteger(pid) || pid <= 0 || !isRunning(pid))
-      break;
-    await sleep3(RELEASE_POLL_MS);
+    await stopContainer(name, STOP_TIMEOUT_SECONDS);
   }
-  await unlink(path).catch(() => {});
 }
-function isRunning(pid) {
+var CLOCK_TICKS_PER_SECOND = 100;
+var START_TIME_SLACK_MS = 2000;
+function isRunning(pid, startedAt) {
   try {
     process.kill(pid, 0);
-    return true;
   } catch {
     return false;
   }
+  if (startedAt === undefined)
+    return true;
+  const written = Date.parse(startedAt);
+  if (Number.isNaN(written))
+    return true;
+  const began = processStart(pid);
+  return began === undefined || began <= written + START_TIME_SLACK_MS;
+}
+function processStart(pid) {
+  try {
+    const stat = readFileSync4(`/proc/${pid}/stat`, "utf8");
+    const fields = stat.slice(stat.lastIndexOf(")") + 2).split(" ");
+    const ticks = Number(fields[19]);
+    const boot = bootTime();
+    if (!Number.isFinite(ticks) || boot === undefined)
+      return;
+    return boot + ticks / CLOCK_TICKS_PER_SECOND * 1000;
+  } catch {
+    return;
+  }
+}
+function bootTime() {
+  const line = readFileSync4("/proc/stat", "utf8").split(`
+`).find((each) => each.startsWith("btime "));
+  const seconds = Number(line?.slice("btime ".length));
+  return Number.isFinite(seconds) && seconds > 0 ? seconds * 1000 : undefined;
 }
 async function captureScreenshot(container, plan) {
   const name = `${plan.game}.png`;
@@ -2772,7 +3266,7 @@ async function captureScreenshot(container, plan) {
 }
 async function writeLaunchRecord(plan, image) {
   const digest = await imageDigest(image);
-  const line2 = JSON.stringify({
+  const line = JSON.stringify({
     at: new Date().toISOString(),
     game: plan.game,
     profile: plan.profile,
@@ -2787,17 +3281,150 @@ async function writeLaunchRecord(plan, image) {
     }))
   });
   const path = join9(plan.instanceDir, ".gamecrate", "launches.jsonl");
-  await writeFile2(path, `${line2}
+  await writeFile2(path, `${line}
 `, { flag: "a" });
 }
 
+// src/launch/supervisor.ts
+import { existsSync as existsSync5 } from "node:fs";
+import { readFile as readFile5, readlink, rm, writeFile as writeFile3 } from "node:fs/promises";
+import { basename as basename7, join as join10 } from "node:path";
+import { setTimeout as sleep4 } from "node:timers/promises";
+async function forkSupervisor(plan, argv) {
+  await clearLock(plan);
+  const name = containerName(plan);
+  const self = supervisorArgv(argv, plan.instanceDir);
+  const bin = self[0];
+  if (bin === undefined || bin === "") {
+    throw new GamecrateError("cannot re-exec gamecrate: argv[0] is empty", Exit.Environment);
+  }
+  const child = spawnArgv(self, "ignore", true);
+  child.unref();
+  if (child.pid === undefined) {
+    throw new GamecrateError(`could not fork a supervisor from ${bin}`, Exit.Environment);
+  }
+  try {
+    await writeLock(plan, {
+      pid: child.pid,
+      container: name,
+      game: plan.game,
+      profile: plan.profile,
+      ...plan.instance === undefined ? {} : { instance: plan.instance },
+      detached: true,
+      mode: plan.mode
+    });
+  } catch (error) {
+    const failure = kill(child.pid);
+    if (failure !== undefined) {
+      throw new GamecrateError(`could not confirm supervisor ${child.pid} died after the lock write failed`, Exit.Environment, `${failure}
+kill -9 ${child.pid} before launching this profile again`);
+    }
+    throw error;
+  }
+  status(`${plan.game} ${plan.profile} -> ${name} (pid ${child.pid})`);
+  return Exit.Ok;
+}
+function kill(pid) {
+  try {
+    process.kill(pid, "SIGKILL");
+    return;
+  } catch (error) {
+    const code = error.code;
+    return code === "ESRCH" ? undefined : `could not kill it: ${code ?? String(error)}`;
+  }
+}
+async function recordExit(plan, result) {
+  await writeExit(plan.instanceDir, {
+    at: new Date().toISOString(),
+    code: result.code,
+    reason: result.reason,
+    container: containerName(plan),
+    runDir: plan.runDirHost
+  });
+}
+async function supervisorFailed(dir, code) {
+  const record = { at: new Date().toISOString(), code, reason: "failed" };
+  const wrote = await writeExit(dir, record).then(() => true, () => false);
+  if (wrote)
+    await rm(join10(dir, ".gamecrate", "lock"), { force: true }).catch(() => {});
+  return code;
+}
+async function writeExit(instanceDir, record) {
+  await writeFile3(join10(instanceDir, ".gamecrate", "last-exit.json"), `${JSON.stringify(record)}
+`);
+}
+async function lastExit(instanceDir) {
+  const text = await readFile5(join10(instanceDir, ".gamecrate", "last-exit.json"), "utf8").catch(() => {
+    return;
+  });
+  if (text === undefined)
+    return;
+  try {
+    const value = JSON.parse(text);
+    return Number.isInteger(value?.code) ? value : undefined;
+  } catch {
+    return;
+  }
+}
+var WAIT_POLL_MS = 500;
+function endedAfter(record, notBefore) {
+  if (notBefore === undefined)
+    return true;
+  const began = Date.parse(notBefore);
+  if (Number.isNaN(began))
+    return true;
+  const at = Date.parse(record.at);
+  return !Number.isNaN(at) && at >= began;
+}
+async function awaitExit(instanceDir, poll = WAIT_POLL_MS) {
+  const file = join10(instanceDir, ".gamecrate", "lock");
+  let watching;
+  for (;; ) {
+    const lock = await readLock(file) ?? watching;
+    const found = await lastExit(instanceDir);
+    if (found !== undefined && endedAfter(found, lock?.startedAt))
+      return found;
+    if (lock === undefined)
+      return "absent";
+    if (!isRunning(lock.pid, lock.startedAt))
+      return "orphaned";
+    watching = lock;
+    await sleep4(poll);
+  }
+}
+var RUN_LOG_POLL_MS = 250;
+async function awaitRunLog(instanceDir, lock, poll = RUN_LOG_POLL_MS, notice = WAIT_NOTICE) {
+  const link = join10(instanceDir, "logs", "current");
+  const written = Date.parse(lock.startedAt);
+  const since = Date.now();
+  let lastNotice = 0;
+  for (;; ) {
+    const target = await readlink(link).catch(() => {
+      return;
+    });
+    const began = target === undefined ? undefined : runStartedAt(basename7(target));
+    const current = began !== undefined && (Number.isNaN(written) || began >= written);
+    if (current && existsSync5(currentLog(instanceDir)))
+      return true;
+    if (!isRunning(lock.pid, lock.startedAt))
+      return false;
+    const waited = Date.now() - since;
+    const label = waitNotice(waited, lastNotice, notice);
+    if (label !== undefined) {
+      status(`waiting for ${lock.game} ${lock.profile} to open its log (${label})`);
+      lastNotice = waited;
+    }
+    await sleep4(poll);
+  }
+}
+
 // src/launch/instance.ts
 import { createHash } from "node:crypto";
-import { basename as basename5, join as join10 } from "node:path";
+import { basename as basename8, join as join11 } from "node:path";
 
 // src/mods/worktree.ts
 import { spawnSync } from "node:child_process";
-import { existsSync as existsSync5, realpathSync as realpathSync2 } from "node:fs";
+import { existsSync as existsSync6, realpathSync as realpathSync2 } from "node:fs";
 import { isAbsolute as isAbsolute2, resolve as resolve4, sep } from "node:path";
 function inspect(dir) {
   const r = spawnSync("git", ["-C", dir, "rev-parse", "--path-format=absolute", "--show-toplevel", "--git-dir", "--git-common-dir", "--abbrev-ref", "HEAD"], { encoding: "utf8" });
@@ -2820,7 +3447,7 @@ function canonical(p) {
 function resolveWorktree(dir, source, order) {
   const raw = expandHome(dir);
   const abs = isAbsolute2(raw) ? raw : resolve4(process.cwd(), raw);
-  if (!existsSync5(abs)) {
+  if (!existsSync6(abs)) {
     return { where: abs, message: `--worktree path does not exist`, suggestion: "check the path, or drop the flag" };
   }
   const info = inspect(abs);
@@ -2840,7 +3467,7 @@ function contains(request, dir) {
   const target = canonical(dir);
   return target === request.root || target.startsWith(request.root + sep);
 }
-function collectRequests(flags2, env, cwd, disabled) {
+function collectRequests(flags, env, cwd, disabled) {
   if (disabled)
     return { requests: [], problems: [] };
   const requests = [];
@@ -2857,7 +3484,7 @@ function collectRequests(flags2, env, cwd, disabled) {
       problems.push(got);
     }
   };
-  for (const f of flags2)
+  for (const f of flags)
     add(f, "flag");
   if (env !== undefined && env !== "" && env !== "off")
     add(env, "env");
@@ -2868,21 +3495,21 @@ function collectRequests(flags2, env, cwd, disabled) {
 // src/launch/instance.ts
 var SLUG_LIMIT = 24;
 function resolveInstance(options) {
-  const { profileDir, profile: profile2, args } = options;
-  const configured = lookup(profile2, args.instance);
-  const flags2 = configured?.worktree === undefined ? args.worktree ?? [] : [configured.worktree, ...args.worktree ?? []];
-  const { requests, problems } = collectRequests(flags2, options.env ?? process.env["GAMECRATE_WORKTREE"], options.cwd ?? process.cwd(), args.noWorktree ?? false);
+  const { profileDir, profile, args } = options;
+  const configured = lookup(profile, args.instance);
+  const flags = configured?.worktree === undefined ? args.worktree ?? [] : [configured.worktree, ...args.worktree ?? []];
+  const { requests, problems } = collectRequests(flags, options.env ?? process.env["GAMECRATE_WORKTREE"], options.cwd ?? process.cwd(), args.noWorktree ?? false);
   const name = args.instance === undefined ? derive(requests) : named(args.instance);
   return {
     ...name === undefined ? {} : { name },
-    dir: name === undefined ? profileDir : join10(profileDir, "instances", name),
+    dir: name === undefined ? profileDir : join11(profileDir, "instances", name),
     requests,
     problems,
     ...configured?.settings === undefined ? {} : { settings: configured.settings }
   };
 }
-function lookup(profile2, name) {
-  const instances = profile2?.instances;
+function lookup(profile, name) {
+  const instances = profile?.instances;
   if (instances === undefined || name === undefined)
     return;
   const exact = own(instances, name);
@@ -2905,22 +3532,22 @@ function derive(requests) {
   const digest = createHash("sha256").update(requests.map((r) => r.root).join("\x00")).digest("hex");
   return `${slug(first.root)}-${digest.slice(0, 6)}`;
 }
-function slug(root2) {
-  const body = basename5(root2).toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^[^a-z0-9]+/, "").slice(0, SLUG_LIMIT).replace(/[-._]+$/, "");
+function slug(root) {
+  const body = basename8(root).toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^[^a-z0-9]+/, "").slice(0, SLUG_LIMIT).replace(/[-._]+$/, "");
   return body === "" ? "wt" : body;
 }
 
 // src/launch/resolve.ts
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 
 // src/mods/modindex.ts
-import { existsSync as existsSync6, readFileSync as readFileSync3, statSync as statSync2 } from "node:fs";
-import { mkdir as mkdir2, readdir as readdir6, readFile as readFile4, writeFile as writeFile3 } from "node:fs/promises";
+import { existsSync as existsSync7, readFileSync as readFileSync5, statSync as statSync2 } from "node:fs";
+import { mkdir as mkdir2, readdir as readdir6, readFile as readFile6, writeFile as writeFile4 } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
-import { dirname as dirname4, join as join11, relative as relative2, resolve as resolvePath } from "node:path";
+import { dirname as dirname4, join as join12, relative as relative2, resolve as resolvePath } from "node:path";
 import picomatch from "picomatch";
 function cacheDir() {
-  return join11(process.env["XDG_CACHE_HOME"] ?? join11(homedir4(), ".cache"), "gamecrate");
+  return join12(process.env["XDG_CACHE_HOME"] ?? join12(homedir4(), ".cache"), "gamecrate");
 }
 function globMatch(pattern, path) {
   return picomatch.isMatch(path, pattern.replace(/[[\]{}()!,@+|^$.\\]/g, "\\$&"), { dot: true });
@@ -2932,8 +3559,8 @@ var ALWAYS_EXCLUDE = ["**/.worktrees/**", "**/.claude/worktrees/**"];
 function inLinkedWorktree(dir, stopAt) {
   let current = dir;
   for (;; ) {
-    const git = join11(current, ".git");
-    if (existsSync6(git)) {
+    const git = join12(current, ".git");
+    if (existsSync7(git)) {
       try {
         if (statSync2(git).isFile())
           return true;
@@ -2950,12 +3577,12 @@ function inLinkedWorktree(dir, stopAt) {
     current = parent;
   }
 }
-async function scanLocalRoot(root2, rootIndex, manifestFile, found) {
-  const base = resolvePath(expandHome(root2.path));
-  const exclude = [...root2.exclude ?? [], ...rootIndex === -1 ? [] : ALWAYS_EXCLUDE];
+async function scanLocalRoot(root, rootIndex, manifestFile, found) {
+  const base = resolvePath(expandHome(root.path));
+  const exclude = [...root.exclude ?? [], ...rootIndex === -1 ? [] : ALWAYS_EXCLUDE];
   const walk = async (dir, depth) => {
-    const manifest = join11(dir, manifestFile);
-    if (existsSync6(manifest)) {
+    const manifest = join12(dir, manifestFile);
+    if (existsSync7(manifest)) {
       found.push({
         dir,
         kind: "local",
@@ -2964,7 +3591,7 @@ async function scanLocalRoot(root2, rootIndex, manifestFile, found) {
       });
       return;
     }
-    if (depth >= root2.maxDepth)
+    if (depth >= root.maxDepth)
       return;
     let entries;
     try {
@@ -2975,13 +3602,13 @@ async function scanLocalRoot(root2, rootIndex, manifestFile, found) {
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".git"))
         continue;
-      const child = join11(dir, entry.name);
+      const child = join12(dir, entry.name);
       if (excluded(exclude, relative2(base, child)))
         continue;
       await walk(child, depth + 1);
     }
   };
-  if (!existsSync6(base))
+  if (!existsSync7(base))
     return;
   await walk(base, 0);
 }
@@ -2996,17 +3623,17 @@ async function scanWorkshopRoot(workshopRoot, rootIndex, manifestFile, found) {
   for (const entry of entries) {
     if (!entry.isDirectory() || !/^\d+$/.test(entry.name))
       continue;
-    const dir = join11(base, entry.name);
-    if (!existsSync6(join11(dir, manifestFile)))
+    const dir = join12(base, entry.name);
+    if (!existsSync7(join12(dir, manifestFile)))
       continue;
     found.push({ dir, kind: "workshop", rootIndex, linkedWorktree: false, workshopId: Number(entry.name) });
   }
 }
-async function scanGameData(game2, rootIndex, found) {
-  const host = game2.gameFiles.host;
-  if (game2.gameFiles.source !== "mount" || host === undefined)
+async function scanGameData(game, rootIndex, found) {
+  const host = game.gameFiles.host;
+  if (game.gameFiles.source !== "mount" || host === undefined)
     return;
-  const data = join11(resolvePath(expandHome(host)), "Data");
+  const data = join12(resolvePath(expandHome(host)), "Data");
   let entries;
   try {
     entries = await readdir6(data, { withFileTypes: true });
@@ -3016,17 +3643,17 @@ async function scanGameData(game2, rootIndex, found) {
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    const dir = join11(data, entry.name);
-    if (!existsSync6(join11(dir, game2.manifest.file)))
+    const dir = join12(data, entry.name);
+    if (!existsSync7(join12(dir, game.manifest.file)))
       continue;
     found.push({ dir, kind: "official", rootIndex, linkedWorktree: false });
   }
 }
 var CACHE_VERSION = 2;
-function workshopStamp(game2) {
-  if (game2.workshopRoot === null)
+function workshopStamp(game) {
+  if (game.workshopRoot === null)
     return null;
-  const acf = join11(dirname4(dirname4(resolvePath(expandHome(game2.workshopRoot)))), `appworkshop_${game2.steamAppId}.acf`);
+  const acf = join12(dirname4(dirname4(resolvePath(expandHome(game.workshopRoot)))), `appworkshop_${game.steamAppId}.acf`);
   try {
     const info = statSync2(acf);
     return `${info.mtimeMs}:${info.size}`;
@@ -3034,9 +3661,9 @@ function workshopStamp(game2) {
     return null;
   }
 }
-async function readWorkshopCache(game2, stamp) {
+async function readWorkshopCache(game, stamp) {
   try {
-    const raw = JSON.parse(await readFile4(join11(cacheDir(), `${game2}.workshop.json`), "utf8"));
+    const raw = JSON.parse(await readFile6(join12(cacheDir(), `${game}.workshop.json`), "utf8"));
     if (raw.version !== CACHE_VERSION || raw.stamp !== stamp)
       return null;
     return raw.records;
@@ -3044,15 +3671,15 @@ async function readWorkshopCache(game2, stamp) {
     return null;
   }
 }
-async function writeWorkshopCache(game2, stamp, records) {
+async function writeWorkshopCache(game, stamp, records) {
   const payload = { version: CACHE_VERSION, stamp, records };
   try {
     await mkdir2(cacheDir(), { recursive: true });
-    await writeFile3(join11(cacheDir(), `${game2}.workshop.json`), JSON.stringify(payload));
+    await writeFile4(join12(cacheDir(), `${game}.workshop.json`), JSON.stringify(payload));
   } catch {}
 }
-function toRecord(candidate, manifest, game2) {
-  const kind = manifest.packageId.toLowerCase() === game2.core.toLowerCase() ? "core" : candidate.kind;
+function toRecord(candidate, manifest, game) {
+  const kind = manifest.packageId.toLowerCase() === game.core.toLowerCase() ? "core" : candidate.kind;
   const record = {
     packageId: manifest.packageId,
     dir: candidate.dir,
@@ -3131,8 +3758,8 @@ async function applySourceOverrides(index, overrides, config) {
     }
     const wanted = spec.slice(0, eq);
     const dir = resolvePath(expandHome(spec.slice(eq + 1)));
-    const file = join11(dir, config.manifest.file);
-    if (!existsSync6(file)) {
+    const file = join12(dir, config.manifest.file);
+    if (!existsSync7(file)) {
       problems.push({
         where: spec,
         message: `no ${config.manifest.file} under ${dir}`,
@@ -3142,7 +3769,7 @@ async function applySourceOverrides(index, overrides, config) {
     }
     let manifest;
     try {
-      manifest = index.plugin.parseManifest(readFileSync3(file, "utf8"));
+      manifest = index.plugin.parseManifest(readFileSync5(file, "utf8"));
     } catch (error) {
       problems.push({ where: file, message: `could not parse: ${String(error)}` });
       continue;
@@ -3193,9 +3820,9 @@ function insert(index, record) {
     }
   }
 }
-async function buildIndex(game2, config, plugin) {
+async function buildIndex(game, config, plugin) {
   const index = {
-    game: game2,
+    game,
     plugin,
     byPackageId: new Map,
     byWorkshopId: new Map,
@@ -3204,14 +3831,14 @@ async function buildIndex(game2, config, plugin) {
   };
   const local = [];
   await scanGameData(config, -1, local);
-  for (const [i, root2] of config.scanRoots.entries()) {
-    await scanLocalRoot(root2, i, config.manifest.file, local);
+  for (const [i, root] of config.scanRoots.entries()) {
+    await scanLocalRoot(root, i, config.manifest.file, local);
   }
   for (const record of await parseAll(local, config, plugin, index.problems))
     insert(index, record);
   if (config.workshopRoot !== null) {
     const stamp = workshopStamp(config);
-    const cached = stamp === null ? null : await readWorkshopCache(game2, stamp);
+    const cached = stamp === null ? null : await readWorkshopCache(game, stamp);
     if (cached) {
       for (const record of cached)
         insert(index, record);
@@ -3222,7 +3849,7 @@ async function buildIndex(game2, config, plugin) {
       for (const record of records)
         insert(index, record);
       if (stamp !== null)
-        await writeWorkshopCache(game2, stamp, records);
+        await writeWorkshopCache(game, stamp, records);
     }
   }
   for (const bucket of index.byPackageId.values())
@@ -3231,9 +3858,9 @@ async function buildIndex(game2, config, plugin) {
 }
 async function parseAll(candidates, config, plugin, problems) {
   const records = await Promise.all(candidates.map(async (candidate) => {
-    const file = join11(candidate.dir, config.manifest.file);
+    const file = join12(candidate.dir, config.manifest.file);
     try {
-      const manifest = plugin.parseManifest(await readFile4(file, "utf8"));
+      const manifest = plugin.parseManifest(await readFile6(file, "utf8"));
       return manifest === null ? null : toRecord(candidate, manifest, config);
     } catch (error) {
       problems.push({
@@ -3245,8 +3872,8 @@ async function parseAll(candidates, config, plugin, problems) {
   }));
   return records.filter((r) => r !== null);
 }
-function resolveModRef(index, ref, game2) {
-  return honorOverride(index, resolveRaw(index, ref, game2));
+function resolveModRef(index, ref, game) {
+  return honorOverride(index, resolveRaw(index, ref, game));
 }
 function honorOverride(index, record) {
   if (record === null || record.overridden !== undefined)
@@ -3254,9 +3881,9 @@ function honorOverride(index, record) {
   const best = index.byPackageId.get(record.packageId.toLowerCase())?.[0];
   return best?.overridden !== undefined ? best : record;
 }
-function resolveRaw(index, ref, game2) {
+function resolveRaw(index, ref, game) {
   if (ref.startsWith("path:"))
-    return byPath(index, ref.slice(5), game2);
+    return byPath(index, ref.slice(5), game);
   if (ref.startsWith("workshop:")) {
     const id = Number(ref.slice(9));
     return Number.isInteger(id) ? index.byWorkshopId.get(id) ?? null : null;
@@ -3264,9 +3891,9 @@ function resolveRaw(index, ref, game2) {
   const direct = pick(index, ref.toLowerCase(), ref);
   if (direct)
     return direct;
-  const alias = own(game2.aliases, ref) ?? own(game2.aliases, ref.toLowerCase());
+  const alias = own(game.aliases, ref) ?? own(game.aliases, ref.toLowerCase());
   if (alias !== undefined && alias.toLowerCase() !== ref.toLowerCase()) {
-    return resolveRaw(index, alias, game2);
+    return resolveRaw(index, alias, game);
   }
   const short = index.byShortName.get(ref.toLowerCase());
   if (short && short.length === 1)
@@ -3295,21 +3922,21 @@ function pick(index, key, ref) {
   }
   return best;
 }
-function byPath(index, raw, game2) {
+function byPath(index, raw, game) {
   const dir = resolvePath(expandHome(raw));
   for (const bucket of index.byPackageId.values()) {
     const hit = bucket.find((record) => record.dir === dir || record.dir === raw);
     if (hit)
       return hit;
   }
-  const file = join11(dir, game2.manifest.file);
-  if (!existsSync6(file))
+  const file = join12(dir, game.manifest.file);
+  if (!existsSync7(file))
     return null;
   try {
-    const manifest = index.plugin.parseManifest(readFileSync3(file, "utf8"));
+    const manifest = index.plugin.parseManifest(readFileSync5(file, "utf8"));
     if (manifest === null)
       return null;
-    return toRecord({ dir, kind: "local", rootIndex: -1, linkedWorktree: false }, manifest, game2);
+    return toRecord({ dir, kind: "local", rootIndex: -1, linkedWorktree: false }, manifest, game);
   } catch {
     return null;
   }
@@ -3321,7 +3948,7 @@ var DEFAULT_RENDER_WAIT_SECONDS = 25;
 function isDynamic(entry) {
   return typeof entry !== "string" && "match" in entry;
 }
-function refFor(entry, game2) {
+function refFor(entry, game) {
   const object = typeof entry === "string" ? { id: entry } : entry;
   if (object.path !== undefined)
     return `path:${object.path}`;
@@ -3329,7 +3956,7 @@ function refFor(entry, game2) {
     return `workshop:${object.workshop}`;
   if (object.id.includes(":"))
     return object.id;
-  const pin = own(game2.library, object.id) ?? own(game2.library, object.id.toLowerCase());
+  const pin = own(game.library, object.id) ?? own(game.library, object.id.toLowerCase());
   if (pin?.path !== undefined)
     return `path:${pin.path}`;
   if (pin?.workshop !== undefined)
@@ -3359,22 +3986,22 @@ function expandDynamic(entry, index, where, problems) {
   }
   return [...head, ...rest];
 }
-function collectSlots(game2, gameName, profileName, profile2, args) {
+function collectSlots(game, gameName, profileName, profile, args) {
   const modless = profileName === "modless";
   const slots = [];
   const at = `/games/${gameName}`;
   if (!modless)
-    for (const [i, id] of (game2.preCore ?? []).entries())
+    for (const [i, id] of (game.preCore ?? []).entries())
       slots.push({ entry: id, where: `${at}/preCore/${i}` });
-  slots.push({ entry: game2.core, where: `${at}/core` });
-  for (const [i, id] of game2.dlc.entries())
+  slots.push({ entry: game.core, where: `${at}/core` });
+  for (const [i, id] of game.dlc.entries())
     slots.push({ entry: id, where: `${at}/dlc/${i}`, dlc: true });
-  if (!modless && profile2.includeBase !== false) {
-    for (const [i, id] of (game2.base ?? []).entries())
+  if (!modless && profile.includeBase !== false) {
+    for (const [i, id] of (game.base ?? []).entries())
       slots.push({ entry: id, where: `${at}/base/${i}` });
   }
   const only = args.only ?? [];
-  const declared = only.length > 0 ? only : profile2.mods ?? [];
+  const declared = only.length > 0 ? only : profile.mods ?? [];
   const source = only.length > 0 ? "flag --only" : `${at}/profiles/${profileName}/mods`;
   for (const [i, entry] of declared.entries())
     slots.push({ entry, where: `${source}/${i}` });
@@ -3382,7 +4009,7 @@ function collectSlots(game2, gameName, profileName, profile2, args) {
     slots.push({ entry: id, where: `flag --mod/${i}` });
   return slots;
 }
-function insertDependencies(list, present, index, game2, problems) {
+function insertDependencies(list, present, index, game, problems) {
   let i = 0;
   outer:
     while (i < list.length) {
@@ -3392,7 +4019,7 @@ function insertDependencies(list, present, index, game2, problems) {
         if (present.has(key))
           continue;
         present.add(key);
-        const record = resolveModRef(index, dep.packageId, game2);
+        const record = resolveModRef(index, dep.packageId, game);
         if (!record) {
           problems.push({
             where: mod.record.packageId,
@@ -3494,47 +4121,47 @@ function incompatibilityWarnings(list) {
   return warnings;
 }
 async function resolvePlan(options) {
-  const { game: gameName, profile: requestedProfile, root: root2 } = options;
+  const { game: gameName, profile: requestedProfile, root } = options;
   const args = options.args ?? {};
   const problems = [];
   const warnings = [];
-  const game2 = own(root2.games, gameName);
-  if (!game2) {
-    throw new GamecrateError(`unknown game "${gameName}"`, Exit.Config, `known: ${Object.keys(root2.games).join(", ")}`);
+  const game = own(root.games, gameName);
+  if (!game) {
+    throw new GamecrateError(`unknown game "${gameName}"`, Exit.Config, `known: ${Object.keys(root.games).join(", ")}`);
   }
   if (!NAME_PATTERN.test(requestedProfile)) {
     throw new GamecrateError(`invalid profile name "${requestedProfile}"`, Exit.Usage);
   }
-  const profileName = canonicalProfile(game2, requestedProfile);
-  const profile2 = profileName === "modless" ? { mods: [], includeBase: false } : resolveProfile(game2, profileName);
-  const profileDir = profileDataDir(root2, gameName, profileName);
+  const profileName = canonicalProfile(game, requestedProfile);
+  const profile = profileName === "modless" ? { mods: [], includeBase: false } : resolveProfile(game, profileName);
+  const profileDir = profileDataDir(root, gameName, profileName);
   const instance = resolveInstance({
     profileDir,
-    profile: profile2,
+    profile,
     args,
     ...options.cwd === undefined ? {} : { cwd: options.cwd }
   });
   problems.push(...instance.problems);
-  const settings2 = resolveSettings(root2, game2, profile2, instance.settings, args.resolution);
+  const settings = resolveSettings(root, game, profile, instance.settings, args.resolution);
   if (args.network !== undefined)
-    settings2.network = args.network;
+    settings.network = args.network;
   if (args.gameArgs?.length)
-    settings2.gameArgs = [...settings2.gameArgs ?? [], ...args.gameArgs];
+    settings.gameArgs = [...settings.gameArgs ?? [], ...args.gameArgs];
   if (args.dockerArgs?.length)
-    settings2.dockerArgs = [...settings2.dockerArgs ?? [], ...args.dockerArgs];
+    settings.dockerArgs = [...settings.dockerArgs ?? [], ...args.dockerArgs];
   const plugin = requirePlugin(options.plugins, gameName);
-  const index = options.index ?? await buildIndex(gameName, game2, plugin);
-  await applyWorktreeRequests(index, instance.requests, game2);
-  problems.push(...await applySourceOverrides(index, args.use ?? [], game2));
-  const excluded2 = [...profile2.exclude ?? [], ...args.without ?? []].map(globToRegExp);
-  const isExcluded = (id) => excluded2.some((pattern) => pattern.test(id));
+  const index = options.index ?? await buildIndex(gameName, game, plugin);
+  await applyWorktreeRequests(index, instance.requests, game);
+  problems.push(...await applySourceOverrides(index, args.use ?? [], game));
+  const excluded = [...profile.exclude ?? [], ...args.without ?? []].map(globToRegExp);
+  const isExcluded = (id) => excluded.some((pattern) => pattern.test(id));
   const staged = [];
   const present = new Set;
-  for (const slot of collectSlots(game2, gameName, profileName, profile2, args)) {
+  for (const slot of collectSlots(game, gameName, profileName, profile, args)) {
     const entry = slot.entry;
-    const refs = isDynamic(entry) ? expandDynamic(entry, index, slot.where, problems).map((id) => ({ ref: id, optional: false })) : [{ ref: refFor(entry, game2), optional: typeof entry !== "string" && entry.optional === true }];
+    const refs = isDynamic(entry) ? expandDynamic(entry, index, slot.where, problems).map((id) => ({ ref: id, optional: false })) : [{ ref: refFor(entry, game), optional: typeof entry !== "string" && entry.optional === true }];
     for (const { ref, optional } of refs) {
-      const record = resolveModRef(index, ref, game2);
+      const record = resolveModRef(index, ref, game);
       if (!record) {
         if (slot.dlc === true)
           continue;
@@ -3551,9 +4178,9 @@ async function resolvePlan(options) {
       staged.push({ record, explicit: true });
     }
   }
-  if (profile2.autoDependencies === true)
-    insertDependencies(staged, present, index, game2, problems);
-  const ordered = args.sort === "none" ? staged : topoSort(staged, problems, game2.core);
+  if (profile.autoDependencies === true)
+    insertDependencies(staged, present, index, game, problems);
+  const ordered = args.sort === "none" ? staged : topoSort(staged, problems, game.core);
   warnings.push(...incompatibilityWarnings(ordered));
   const mods = [];
   for (const { record, explicit } of ordered) {
@@ -3566,7 +4193,7 @@ async function resolvePlan(options) {
     mods.push({
       packageId: record.packageId,
       hostDir: record.dir,
-      containerDir: `${game2.modsDir.container}/${record.packageId}`,
+      containerDir: `${game.modsDir.container}/${record.packageId}`,
       kind: record.kind,
       ...record.workshopId === undefined ? {} : { workshopId: record.workshopId },
       explicit,
@@ -3577,37 +4204,37 @@ async function resolvePlan(options) {
     });
   }
   problems.push(...index.problems);
-  if (game2.dataDir.mode === "arg" && game2.dataDir.arg.split("=").length !== 2) {
+  if (game.dataDir.mode === "arg" && game.dataDir.arg.split("=").length !== 2) {
     problems.push({
       where: `/games/${gameName}/dataDir/arg`,
-      message: `"${game2.dataDir.arg}" must contain exactly one "="; RimWorld silently ignores anything else`
+      message: `"${game.dataDir.arg}" must contain exactly one "="; RimWorld silently ignores anything else`
     });
   }
-  if (game2.dataDir.container.includes("=")) {
+  if (game.dataDir.container.includes("=")) {
     problems.push({
       where: `/games/${gameName}/dataDir/container`,
-      message: `container data path "${game2.dataDir.container}" contains "=", which disables the override silently`
+      message: `container data path "${game.dataDir.container}" contains "=", which disables the override silently`
     });
   }
   const mode = args.mode ?? "headed";
-  if (!game2.modes.includes(mode)) {
+  if (!game.modes.includes(mode)) {
     problems.push({ where: "flag --mode", message: `${gameName} does not support mode "${mode}"` });
   }
   const plan = {
     game: gameName,
-    gameConfig: game2,
+    gameConfig: game,
     plugin,
     profile: profileName,
-    settings: settings2,
+    settings,
     mods,
     profileDir,
     ...instance.name === undefined ? {} : { instance: instance.name },
     instanceDir: instance.dir,
-    dataDirHost: join12(instance.dir, "game"),
-    configDirHost: join12(profileDir, "config"),
-    stageDirHost: join12(instance.dir, ".stage"),
-    logsDirHost: join12(instance.dir, "logs"),
-    runDirHost: join12(instance.dir, "logs"),
+    dataDirHost: join13(instance.dir, "game"),
+    configDirHost: join13(profileDir, "config"),
+    stageDirHost: join13(instance.dir, ".stage"),
+    logsDirHost: join13(instance.dir, "logs"),
+    runDirHost: join13(instance.dir, "logs"),
     mode,
     ...args.marker === undefined ? {} : { marker: args.marker },
     timeoutSeconds: args.timeout ?? DEFAULT_TIMEOUT_SECONDS,
@@ -3618,11 +4245,100 @@ async function resolvePlan(options) {
   return { plan, problems };
 }
 
+// src/run/registry.ts
+import { readdir as readdir7 } from "node:fs/promises";
+import { join as join14 } from "node:path";
+var FORMAT = '{{.Names}}\t{{.Label "gamecrate.game"}}\t{{.Label "gamecrate.profile"}}\t{{.Label "gamecrate.instance"}}\t{{.Status}}';
+function parseDockerRuns(stdout) {
+  const out = [];
+  for (const line of stdout.split(`
+`)) {
+    if (line.trim() === "")
+      continue;
+    const [container, game, profile, instance, uptime] = line.split("\t");
+    if (container === undefined || game === undefined || profile === undefined)
+      continue;
+    out.push({
+      game,
+      profile,
+      ...instance ? { instance } : {},
+      container,
+      ...uptime ? { uptime } : {},
+      status: "running"
+    });
+  }
+  return out;
+}
+async function walkLocks(dataRoot) {
+  const out = [];
+  for (const game of await entries(dataRoot)) {
+    const gameDir = join14(dataRoot, game);
+    for (const profile of await entries(gameDir)) {
+      const profileDir = join14(gameDir, profile);
+      await push(out, join14(profileDir, ".gamecrate", "lock"));
+      const instancesDir = join14(profileDir, "instances");
+      for (const instance of await entries(instancesDir)) {
+        await push(out, join14(instancesDir, instance, ".gamecrate", "lock"));
+      }
+    }
+  }
+  return out;
+}
+async function entries(dir) {
+  const found = await readdir7(dir, { withFileTypes: true }).catch(() => []);
+  return found.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+}
+async function push(out, path) {
+  const record = await readLock(path);
+  if (record !== undefined)
+    out.push(record);
+}
+var dockerPs = async () => {
+  const { code, stdout } = await capture([
+    "docker",
+    "ps",
+    "--filter",
+    "label=gamecrate.game",
+    "--format",
+    FORMAT
+  ]);
+  return code === 0 ? stdout : "";
+};
+async function listRuns(dataRoot, docker = dockerPs) {
+  const running = parseDockerRuns(await docker());
+  const byContainer = new Map(running.map((run) => [run.container, run]));
+  const out = [...running];
+  for (const lock of await walkLocks(dataRoot)) {
+    const match = byContainer.get(lock.container);
+    if (match !== undefined) {
+      const stale = match.pid !== undefined && !isRunning(match.pid, match.startedAt);
+      if (match.pid === undefined || stale && isRunning(lock.pid, lock.startedAt)) {
+        match.pid = lock.pid;
+        match.startedAt = lock.startedAt;
+        if (lock.mode !== undefined)
+          match.mode = lock.mode;
+      }
+      continue;
+    }
+    out.push({
+      game: lock.game,
+      profile: lock.profile,
+      ...lock.instance === undefined ? {} : { instance: lock.instance },
+      container: lock.container,
+      pid: lock.pid,
+      ...lock.mode === undefined ? {} : { mode: lock.mode },
+      startedAt: lock.startedAt,
+      status: isRunning(lock.pid, lock.startedAt) ? "starting" : "orphaned"
+    });
+  }
+  return out;
+}
+
 // src/launch/stage.ts
-import { lstat, mkdir as mkdir3, readdir as readdir7, realpath, rm, stat as stat3 } from "node:fs/promises";
-import { basename as basename6, join as join13 } from "node:path";
+import { lstat, mkdir as mkdir3, readdir as readdir8, realpath, rm as rm2, stat as stat3 } from "node:fs/promises";
+import { basename as basename9, join as join15 } from "node:path";
 async function stageMods(plan) {
-  await rm(plan.stageDirHost, { recursive: true, force: true });
+  await rm2(plan.stageDirHost, { recursive: true, force: true });
   await mkdir3(plan.stageDirHost, { recursive: true });
   const mounts = [];
   for (const mod of plan.mods) {
@@ -3637,7 +4353,7 @@ async function stageMods(plan) {
     if (!(await stat3(source)).isDirectory()) {
       throw new GamecrateError(`${mod.packageId} does not resolve to a directory`, Exit.Environment, source);
     }
-    await mkdir3(join13(plan.stageDirHost, basename6(mod.containerDir)), { recursive: true });
+    await mkdir3(join15(plan.stageDirHost, basename9(mod.containerDir)), { recursive: true });
     mounts.push({ type: "bind", source, target: mod.containerDir, readonly: true });
   }
   return mounts;
@@ -3647,12 +4363,12 @@ async function ensureProfileTree(plan) {
     plan.profileDir,
     plan.instanceDir,
     plan.dataDirHost,
-    join13(plan.configDirHost, "config"),
-    join13(plan.configDirHost, "data"),
-    join13(plan.configDirHost, "cache"),
-    join13(plan.logsDirHost, "runs"),
+    join15(plan.configDirHost, "config"),
+    join15(plan.configDirHost, "data"),
+    join15(plan.configDirHost, "cache"),
+    join15(plan.logsDirHost, "runs"),
     plan.stageDirHost,
-    join13(plan.instanceDir, ".gamecrate"),
+    join15(plan.instanceDir, ".gamecrate"),
     ...engineDirs(plan)
   ]) {
     await mkdir3(dir, { recursive: true });
@@ -3662,7 +4378,7 @@ function engineDirs(plan) {
   const { dataDir, modsDir } = plan.gameConfig;
   if (!modsDir.container.startsWith(`${dataDir.container}/`))
     return [];
-  return [join13(plan.dataDirHost, modsDir.container.slice(dataDir.container.length + 1))];
+  return [join15(plan.dataDirHost, modsDir.container.slice(dataDir.container.length + 1))];
 }
 async function detectForeignOwnership(dir, uid, limit = 100) {
   const foreign = [];
@@ -3683,8 +4399,8 @@ async function detectForeignOwnership(dir, uid, limit = 100) {
     if (!info.isDirectory())
       continue;
     try {
-      for (const entry of await readdir7(current))
-        queue.push(join13(current, entry));
+      for (const entry of await readdir8(current))
+        queue.push(join15(current, entry));
     } catch {
       continue;
     }
@@ -3693,58 +4409,77 @@ async function detectForeignOwnership(dir, uid, limit = 100) {
 }
 
 // src/index.ts
-var VERSION = "0.1.0";
-var STOP_TIMEOUT_SECONDS = 10;
+var VERSION = "1.1.0";
 async function main(argv) {
+  const supervised = supervisedDir(argv);
+  try {
+    return await command(argv, supervised);
+  } catch (error) {
+    if (supervised === undefined)
+      throw error;
+    return await supervisorFailed(supervised, reportFatal(error));
+  }
+}
+async function command(argv, supervised) {
   const probe = parseArgs(argv);
   if (probe.subcommand === "version") {
     process.stdout.write(`gamecrate ${VERSION}
 `);
     return Exit.Ok;
   }
-  const [{ config, plugins }, defaults] = await Promise.all([loadConfig(), loadProjectDefaults()]);
+  const defaults = await loadProjectDefaults();
+  const { config, plugins } = await loadConfig(undefined, defaults);
   const args = parseArgs(argv, { games: Object.keys(config.games), defaults });
   if (args.help) {
     process.stdout.write(renderHelp(helpTopic(args), config));
     return Exit.Ok;
   }
-  const redirect = args.log !== undefined && (args.subcommand === "run" || args.subcommand === "shell") ? redirectOutput(args.log) : undefined;
+  const redirect = args.log !== undefined && (args.subcommand === "run" || args.subcommand === "shell") ? redirectOutput(args.log, args.supervised) : undefined;
   try {
-    return await dispatch(args, config, plugins);
+    return await dispatch(argv, args, config, plugins, defaults);
   } catch (error) {
-    return reportFatal(error);
+    const code = reportFatal(error);
+    return supervised === undefined ? code : await supervisorFailed(supervised, code);
   } finally {
     redirect?.close();
   }
 }
-async function dispatch(args, config, plugins) {
+async function dispatch(argv, args, config, plugins, defaults) {
   switch (args.subcommand) {
     case "help":
       return help(args, config);
     case "list":
-      return list(args, config);
+      return list(args, config, defaults);
     case "mods":
-      return mods(args, config, plugins);
+      return mods(args, config, plugins, defaults);
     case "doctor":
       return doctor(config, plugins);
     case "clean":
-      return clean(args, config);
+      return clean(args, config, defaults);
     case "clone":
       return clone(args, config);
     case "logs":
-      return logs(args, config);
+      return logs(args, config, defaults);
     case "verify":
-      return verify(args, config, plugins);
+      return verify(args, config, plugins, defaults);
     case "build":
       return build(args, config);
+    case "ps":
+      return ps(args, config);
+    case "stop":
+      return stop(args, config, defaults);
+    case "attach":
+      return attach(args, config, defaults);
+    case "wait":
+      return waitFor(args, config, defaults);
     case "shell":
-      return run(args, config, plugins, true);
+      return run(argv, args, config, plugins, defaults, true);
     case "config":
       return configEdit(args);
     case "fix-perms":
       return fixPerms(args, config);
     case "run":
-      return run(args, config, plugins, false);
+      return run(argv, args, config, plugins, defaults, false);
     default:
       throw new GamecrateError(`no such subcommand ${args.subcommand}`, Exit.Usage);
   }
@@ -3769,89 +4504,92 @@ function help(args, config) {
   process.stdout.write(renderHelp(topic, config));
   return Exit.Ok;
 }
-function requireGame(args, config) {
-  const game2 = args.game;
-  if (game2 === undefined) {
-    throw new GamecrateError(`${args.subcommand} needs a game`, Exit.Usage, `known games: ${Object.keys(config.games).join(", ")}`);
-  }
-  if (!Object.hasOwn(config.games, game2)) {
-    throw new GamecrateError(`unknown game "${game2}"`, Exit.Config, `known games: ${Object.keys(config.games).join(", ")}`);
-  }
-  return game2;
-}
-function instanceDir(args, config, game2, profile2) {
-  const dir = profileDataDir(config, game2, profile2);
+function instanceDir(args, config, game, profile) {
+  const dir = profileDataDir(config, game, profile);
   let spec;
   try {
-    spec = resolveProfile(config.games[game2], profile2);
+    spec = resolveProfile(config.games[game], profile);
   } catch {
     spec = undefined;
   }
   return resolveInstance({ profileDir: dir, ...spec === undefined ? {} : { profile: spec }, args }).dir;
 }
 function reportEnvironment(problems) {
-  process.stderr.write(`${problems.length} environment problem(s):
-`);
+  const out = [];
   for (const problem of problems) {
-    process.stderr.write(`  ${problem.where}
-    ${problem.message}
-`);
+    out.push(`  ${problem.where}
+    ${problem.message}`);
     if (problem.suggestion)
-      process.stderr.write(`      try: ${problem.suggestion}
-`);
+      out.push(`      try: ${problem.suggestion}`);
   }
-  process.exit(Exit.Environment);
+  throw new GamecrateError(`${problems.length} environment problem(s)`, Exit.Environment, out.join(`
+`));
 }
-async function run(args, config, plugins, asShell) {
-  const game2 = requireGame(args, config);
-  const profile2 = args.profile ?? "modless";
-  const index = await buildIndex(game2, config.games[game2], requirePlugin(plugins, game2));
-  const { plan, problems } = await resolvePlan({ game: game2, profile: profile2, root: config, plugins, args, index });
+async function run(argv, args, config, plugins, defaults, asShell) {
+  const game = requireGame(args, config);
+  const profile = profileOf(args, defaults);
+  const index = await buildIndex(game, config.games[game], requirePlugin(plugins, game));
+  const { plan, problems } = await resolvePlan({ game, profile, root: config, plugins, args, index });
   if (problems.length > 0)
     reportProblems(problems);
   const identity = resolveIdentity(args.root);
   if (args.printPlan || args.dryRun) {
-    const environment2 = await preflight(plan);
+    const environment = await preflight(plan);
     buildRunSpec(plan, [], identity);
     if (args.printPlan)
       printPlan(plan, args.json);
     for (const warning of planWarnings(plan))
       warn(warning);
-    if (environment2.length > 0)
-      return reportEnvironment(environment2);
+    if (environment.length > 0)
+      reportEnvironment(environment);
     if (!args.printPlan) {
-      const what = plan.instance === undefined ? profile2 : `${profile2}/${plan.instance}`;
-      status(`${game2} ${what}: ${plan.mods.length} mods resolve cleanly`);
+      const what = plan.instance === undefined ? profile : `${profile}/${plan.instance}`;
+      status(`${game} ${what}: ${plan.mods.length} mods resolve cleanly`);
     }
     return Exit.Ok;
   }
   const environment = await preflight(plan);
   if (environment.length > 0)
-    return reportEnvironment(environment);
+    reportEnvironment(environment);
   await ensureProfileTree(plan);
-  if (args.replace)
+  const profileSpec = resolveProfile(config.games[game], profile);
+  if (wantsReplace(args, profileSpec))
     await replacePrevious(plan);
-  const lock = await takeLock(plan);
+  if (!asShell && wantsDetach(args, profileSpec))
+    return await forkSupervisor(plan, argv);
+  const lock = args.supervised ? heldLock(plan) : await takeLock(plan);
   try {
-    return await launch(plan, args, config, identity, asShell);
+    const result = await launch(plan, args, config, identity, asShell, profileSpec);
+    if (args.supervised)
+      await recordExit(plan, result);
+    return result.code;
   } finally {
     await lock.release();
   }
 }
-async function launch(plan, args, config, identity, asShell) {
-  const game2 = plan.game;
-  const profile2 = plan.profile;
+async function launch(plan, args, config, identity, asShell, profileSpec) {
+  const game = plan.game;
+  const profile = plan.profile;
   const foreign = await detectForeignOwnership(plan.dataDirHost, identity.uid, 5);
   if (foreign.length > 0) {
     throw new GamecrateError(`${foreign.length} path(s) under ${plan.dataDirHost} are not owned by uid ${identity.uid}`, Exit.Environment, `${foreign.join(`
 `)}
-run: gamecrate fix-perms ${game2} ${profile2}`);
+run: gamecrate fix-perms ${game} ${profile}`);
   }
   const runDir = openRunLog(plan.logsDirHost);
   plan.runDirHost = runDir;
-  await buildLocalMods(plan, args.build ?? "auto");
-  await acquireImage(game2, config.games[game2], args.pull ?? "missing");
-  const runtimeImage = plan.mode === "headed" ? config.games[game2].image.ref : await ensureRuntimeLayer(config.games[game2].image.ref);
+  const supervisorLog = args.supervised && args.log === undefined ? redirectOutput(join16(runDir, "supervisor.log")) : undefined;
+  try {
+    return await execute(plan, args, config, identity, asShell, profileSpec, runDir);
+  } finally {
+    supervisorLog?.close();
+  }
+}
+async function execute(plan, args, config, identity, asShell, profileSpec, runDir) {
+  const game = plan.game;
+  await buildLocalMods(plan, buildPolicy(args, profileSpec));
+  await acquireImage(game, config.games[game], args.pull ?? "missing");
+  const runtimeImage = plan.mode === "headed" ? config.games[game].image.ref : await ensureRuntimeLayer(config.games[game].image.ref);
   const modMounts = await stageMods(plan);
   await generateModsConfig(plan);
   await mergePrefs(plan);
@@ -3886,7 +4624,9 @@ run: gamecrate fix-perms ${game2} ${profile2}`);
         logDir: runDir,
         stopTimeoutSeconds: STOP_TIMEOUT_SECONDS
       });
-      return windowClosed ? Exit.Ok : normalize(code);
+      if (windowClosed)
+        return { code: Exit.Ok, reason: "window-closed" };
+      return { code: normalize(code), reason: reasonFor(code) };
     } finally {
       window?.stop();
     }
@@ -3895,42 +4635,42 @@ run: gamecrate fix-perms ${game2} ${profile2}`);
   }
 }
 function markerSources(plan, logDir) {
-  const sources = [join14(logDir, STDOUT_LOG)];
+  const sources = [join16(logDir, STDOUT_LOG)];
   const { logFile } = plan.gameConfig;
   if (logFile.mode === "arg")
-    sources.push(join14(logDir, "Player.log"));
+    sources.push(join16(logDir, "Player.log"));
   else
-    sources.push(join14(plan.dataDirHost, logFile.from));
+    sources.push(join16(plan.dataDirHost, logFile.from));
   return sources;
 }
 async function runBounded(spec, plan, logDir) {
   const container = runContainer(spec, { logDir, stopTimeoutSeconds: STOP_TIMEOUT_SECONDS });
   const winner = await Promise.race([
     container.then((code) => ({ kind: "exit", code })),
-    sleep4(plan.timeoutSeconds * 1000).then(() => ({ kind: "timeout" }))
+    sleep5(plan.timeoutSeconds * 1000).then(() => ({ kind: "timeout" }))
   ]);
   if (winner.kind === "exit")
-    return normalize(winner.code);
+    return { code: normalize(winner.code), reason: reasonFor(winner.code) };
   status(`no marker given; stopping after ${plan.timeoutSeconds}s`);
   await stopContainer(spec.name, STOP_TIMEOUT_SECONDS);
   await container;
-  return Exit.Ok;
+  return { code: Exit.Ok, reason: "timeout" };
 }
 async function runWithScreenshot(spec, plan, logDir) {
   const container = runContainer(spec, { logDir, stopTimeoutSeconds: STOP_TIMEOUT_SECONDS });
-  const settled = sleep4(plan.renderWaitSeconds * 1000).then(() => "ready");
+  const settled = sleep5(plan.renderWaitSeconds * 1000).then(() => "ready");
   const winner = await Promise.race([
     container.then((code) => ({ kind: "exit", code })),
     settled.then(() => ({ kind: "ready" }))
   ]);
   if (winner.kind === "exit") {
     status(`game exited before the ${plan.renderWaitSeconds}s render wait finished; no frame captured`);
-    return normalize(winner.code);
+    return { code: normalize(winner.code), reason: reasonFor(winner.code) };
   }
   const shot = await grabFrame(spec.name, plan);
   await stopContainer(spec.name, STOP_TIMEOUT_SECONDS);
   await container;
-  return shot === null ? Exit.Environment : Exit.Ok;
+  return { code: shot === null ? Exit.Environment : Exit.Ok, reason: "stopped" };
 }
 async function grabFrame(container, plan) {
   const path = await captureScreenshot(container, plan);
@@ -3949,17 +4689,17 @@ async function runWithMarker(spec, plan, logDir) {
     seen.then((hit) => ({ kind: "marker", hit }))
   ]);
   if (winner.kind === "exit")
-    return normalize(winner.code);
+    return { code: normalize(winner.code), reason: reasonFor(winner.code) };
   if (plan.mode === "screenshot")
     await grabFrame(spec.name, plan);
   await stopContainer(spec.name, STOP_TIMEOUT_SECONDS);
   await container;
   if (winner.hit) {
     status(`marker seen: ${marker}`);
-    return Exit.Ok;
+    return { code: Exit.Ok, reason: "marker" };
   }
   status(`marker "${marker}" not seen within ${plan.timeoutSeconds}s`);
-  return Exit.MarkerTimeout;
+  return { code: Exit.MarkerTimeout, reason: "marker-timeout" };
 }
 function normalize(code) {
   return Number.isInteger(code) && code >= 0 && code <= 255 ? code : Exit.GameFailed;
@@ -3968,72 +4708,21 @@ async function copyOutLogs(plan) {
   const spec = plan.gameConfig.logFile;
   if (spec.mode !== "copy-out")
     return;
-  const source = join14(plan.dataDirHost, spec.from);
-  if (!existsSync7(source))
+  const source = join16(plan.dataDirHost, spec.from);
+  if (!existsSync8(source))
     return;
-  const target = join14(plan.runDirHost, basename7(spec.from.replace(/\/+$/, "")));
+  const target = join16(plan.runDirHost, basename10(spec.from.replace(/\/+$/, "")));
   try {
     await cp(source, target, { recursive: true, force: true });
   } catch (error) {
     warn(`could not copy ${source}: ${describe(error)}`);
   }
 }
-function list(args, config) {
-  const games = args.game === undefined ? Object.keys(config.games) : [requireGame(args, config)];
-  if (args.json) {
-    const payload = games.map((name) => {
-      const game2 = config.games[name];
-      return {
-        game: name,
-        core: game2.core,
-        dlc: game2.dlc,
-        modes: game2.modes,
-        profiles: Object.entries(game2.profiles).map(([profile2, spec]) => ({
-          profile: profile2,
-          alias: spec.alias ?? null,
-          extends: spec.extends ?? null,
-          mods: spec.mods?.length ?? 0,
-          instances: Object.keys(spec.instances ?? {})
-        }))
-      };
-    });
-    process.stdout.write(`${JSON.stringify(payload, null, 2)}
-`);
-    return Exit.Ok;
-  }
-  const out = [];
-  for (const name of games) {
-    const game2 = config.games[name];
-    const width = Math.max(7, ...Object.keys(game2.profiles).map((n) => n.length));
-    out.push(`${name}  (${game2.modes.join(", ")})`);
-    out.push(`  ${"modless".padEnd(width)}  built-in: core + official DLC`);
-    for (const [profile2, spec] of Object.entries(game2.profiles)) {
-      const notes = [];
-      if (spec.alias)
-        notes.push(`alias for ${spec.alias}`);
-      if (spec.extends)
-        notes.push(`extends ${spec.extends}`);
-      const count = spec.mods?.length ?? 0;
-      if (!spec.alias)
-        notes.push(count === 1 ? "1 entry" : `${count} entries`);
-      if (spec.aliases?.length)
-        notes.push(`aka ${spec.aliases.join(", ")}`);
-      out.push(`  ${profile2.padEnd(width)}  ${notes.join(", ")}`);
-      const instances = Object.keys(spec.instances ?? {});
-      if (instances.length > 0)
-        out.push(`  ${" ".repeat(width)}  instances: ${instances.join(", ")}`);
-    }
-  }
-  process.stdout.write(`${out.join(`
-`)}
-`);
-  return Exit.Ok;
-}
-async function mods(args, config, plugins) {
-  const game2 = requireGame(args, config);
-  const profile2 = args.profile ?? "modless";
-  const index = await buildIndex(game2, config.games[game2], requirePlugin(plugins, game2));
-  const { plan, problems } = await resolvePlan({ game: game2, profile: profile2, root: config, plugins, args, index });
+async function mods(args, config, plugins, defaults) {
+  const game = requireGame(args, config);
+  const profile = profileOf(args, defaults);
+  const index = await buildIndex(game, config.games[game], requirePlugin(plugins, game));
+  const { plan, problems } = await resolvePlan({ game, profile, root: config, plugins, args, index });
   if (problems.length > 0)
     reportProblems(problems);
   printPlan(plan, args.json);
@@ -4041,15 +4730,15 @@ async function mods(args, config, plugins) {
 }
 async function doctor(config, plugins) {
   let failed = false;
-  for (const game2 of Object.keys(config.games)) {
-    const { plan, problems } = await resolvePlan({ game: game2, profile: "modless", root: config, plugins });
+  for (const game of Object.keys(config.games)) {
+    const { plan, problems } = await resolvePlan({ game, profile: "modless", root: config, plugins });
     const all = [...problems, ...await preflight(plan)];
     if (all.length === 0) {
-      status(`${game2}: ok`);
+      status(`${game}: ok`);
       continue;
     }
     failed = true;
-    status(`${game2}: ${all.length} problem(s)`);
+    status(`${game}: ${all.length} problem(s)`);
     for (const problem of all) {
       process.stderr.write(`  ${problem.where}
     ${problem.message}
@@ -4061,28 +4750,31 @@ async function doctor(config, plugins) {
   }
   return failed ? Exit.Environment : Exit.Ok;
 }
-async function logs(args, config) {
-  const game2 = requireGame(args, config);
-  const profile2 = args.profile ?? "modless";
-  const runs = join14(instanceDir(args, config, game2, profile2), "logs", "runs");
-  const latest = (await readdir8(runs, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort().at(-1);
+async function logs(args, config, defaults) {
+  const game = requireGame(args, config);
+  const profile = profileOf(args, defaults);
+  const dir = instanceDir(args, config, game, profile);
+  if (args.follow)
+    return await follow(dir, false, `${game} ${profile}`);
+  const runs = join16(dir, "logs", "runs");
+  const latest = (await readdir9(runs, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort().at(-1);
   if (latest === undefined) {
-    throw new GamecrateError(`no runs recorded for ${game2} ${profile2}`, Exit.Usage, runs);
+    throw new GamecrateError(`no runs recorded for ${game} ${profile}`, Exit.Usage, runs);
   }
-  const dir = join14(runs, latest);
-  const files = (await readdir8(dir, { withFileTypes: true })).filter((entry) => entry.isFile()).map((entry) => entry.name).sort();
+  const runDir = join16(runs, latest);
+  const files = (await readdir9(runDir, { withFileTypes: true })).filter((entry) => entry.isFile()).map((entry) => entry.name).sort();
   if (args.json) {
-    process.stdout.write(`${JSON.stringify({ run: latest, dir, files }, null, 2)}
+    process.stdout.write(`${JSON.stringify({ run: latest, dir: runDir, files }, null, 2)}
 `);
     return Exit.Ok;
   }
-  status(dir);
+  status(runDir);
   for (const name of files) {
-    const text = await readFile5(join14(dir, name), "utf8").catch(() => "");
-    for (const line2 of text.split(`
+    const text = await readFile7(join16(runDir, name), "utf8").catch(() => "");
+    for (const line of text.split(`
 `)) {
-      if (line2.length > 0)
-        process.stdout.write(`${name}: ${line2}
+      if (line.length > 0)
+        process.stdout.write(`${name}: ${line}
 `);
     }
   }
@@ -4116,10 +4808,10 @@ function boundStatus(mod) {
     return "OK";
   return mod.hasSources ? "STALE - never built" : "(xml only)";
 }
-async function verify(args, config, plugins) {
-  const game2 = requireGame(args, config);
-  const profile2 = args.profile ?? "modless";
-  const { plan, problems } = await resolvePlan({ game: game2, profile: profile2, root: config, plugins, args });
+async function verify(args, config, plugins, defaults) {
+  const game = requireGame(args, config);
+  const profile = profileOf(args, defaults);
+  const { plan, problems } = await resolvePlan({ game, profile, root: config, plugins, args });
   if (problems.length > 0)
     reportProblems(problems);
   const name = containerName(plan);
@@ -4187,8 +4879,8 @@ function renderVerify(name, info, plan, boundMods) {
   const stamps = boundMods.map((mod) => mod.assembly === null ? "no assemblies" : `${mod.assembly.path}  ${ago(mod.assembly.mtimeMs)}`);
   const stampWidth = Math.max(...stamps.map((s) => s.length));
   for (const [i, mod] of boundMods.entries()) {
-    const origin2 = mod.branch === null ? "" : `worktree ${mod.branch}`;
-    out.push(`  ${mod.packageId.padEnd(idWidth)}  ${paths[i].padEnd(pathWidth)} ${origin2}`.trimEnd());
+    const origin = mod.branch === null ? "" : `worktree ${mod.branch}`;
+    out.push(`  ${mod.packageId.padEnd(idWidth)}  ${paths[i].padEnd(pathWidth)} ${origin}`.trimEnd());
     out.push(`  ${" ".repeat(idWidth)}  ${stamps[i].padEnd(stampWidth)}   ${boundStatus(mod)}`);
   }
   return out.join(`
@@ -4198,17 +4890,15 @@ function shortenHome(path) {
   const home = homedir5();
   return path === home || path.startsWith(`${home}/`) ? `~${path.slice(home.length)}` : path;
 }
-async function clean(args, config) {
-  const game2 = requireGame(args, config);
-  const profile2 = args.profile;
-  if (profile2 === undefined)
-    throw new GamecrateError("clean needs a profile", Exit.Usage);
-  const dir = profileDataDir(config, game2, profile2);
-  const tier2 = args.cleanTier ?? "staging";
-  const saveSuffixes = config.games[game2].saveExtensions.map((ext) => `.${ext.replace(/^\./, "")}`.toLowerCase());
-  if (tier2 !== "all") {
-    const target = join14(instanceDir(args, config, game2, profile2), tier2 === "logs" ? "logs" : ".stage");
-    await rm2(target, { recursive: true, force: true });
+async function clean(args, config, defaults) {
+  const game = requireGame(args, config);
+  const profile = profileOf(args, defaults);
+  const dir = profileDataDir(config, game, profile);
+  const tier = args.cleanTier ?? "staging";
+  const saveSuffixes = config.games[game].saveExtensions.map((ext) => `.${ext.replace(/^\./, "")}`.toLowerCase());
+  if (tier !== "all") {
+    const target = join16(instanceDir(args, config, game, profile), tier === "logs" ? "logs" : ".stage");
+    await rm3(target, { recursive: true, force: true });
     status(`removed ${target}`);
     return Exit.Ok;
   }
@@ -4216,7 +4906,7 @@ async function clean(args, config) {
   if (!args.yes) {
     throw new GamecrateError(`clean --all would delete ${dir}, including ${saves} save file(s)`, Exit.Usage, "add --yes to confirm");
   }
-  await rm2(dir, { recursive: true, force: true });
+  await rm3(dir, { recursive: true, force: true });
   status(`removed ${dir} (${saves} save file(s))`);
   return Exit.Ok;
 }
@@ -4227,13 +4917,13 @@ async function countSaves(dir, suffixes) {
     const current = queue.shift();
     let entries;
     try {
-      entries = await readdir8(current, { withFileTypes: true });
+      entries = await readdir9(current, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
       if (entry.isDirectory())
-        queue.push(join14(current, entry.name));
+        queue.push(join16(current, entry.name));
       else if (suffixes.some((s) => entry.name.toLowerCase().endsWith(s)))
         count++;
     }
@@ -4241,16 +4931,16 @@ async function countSaves(dir, suffixes) {
   return count;
 }
 async function clone(args, config) {
-  const game2 = requireGame(args, config);
+  const game = requireGame(args, config);
   const [src, dst] = args.rest;
   if (src === undefined || dst === undefined) {
     throw new GamecrateError("clone needs a source and a destination profile", Exit.Usage);
   }
-  const from = join14(profileDataDir(config, game2, src), "game");
-  const to = join14(profileDataDir(config, game2, dst), "game");
-  if (!existsSync7(from))
+  const from = join16(profileDataDir(config, game, src), "game");
+  const to = join16(profileDataDir(config, game, dst), "game");
+  if (!existsSync8(from))
     throw new GamecrateError(`${from} does not exist`, Exit.Usage);
-  if (existsSync7(to) && !args.yes) {
+  if (existsSync8(to) && !args.yes) {
     throw new GamecrateError(`${to} already exists`, Exit.Usage, "add --yes to overwrite");
   }
   await mkdir4(to, { recursive: true });
@@ -4260,22 +4950,103 @@ async function clone(args, config) {
   status(`cloned ${from} -> ${to}`);
   return Exit.Ok;
 }
+async function ps(args, config) {
+  const runs = await listRuns(config.dataRoot);
+  if (args.json) {
+    process.stdout.write(`${JSON.stringify(runs, null, 2)}
+`);
+    return Exit.Ok;
+  }
+  if (runs.length === 0) {
+    status("nothing running");
+    return Exit.Ok;
+  }
+  const rows = runs.map((entry) => [
+    entry.game,
+    entry.instance === undefined ? entry.profile : `${entry.profile}/${entry.instance}`,
+    entry.mode ?? "",
+    entry.pid === undefined ? "" : String(entry.pid),
+    entry.container,
+    entry.uptime ?? entry.status
+  ]);
+  const widths = rows[0].map((_, i) => Math.max(...rows.map((row) => row[i].length)));
+  for (const row of rows) {
+    process.stdout.write(`${row.map((cell, i) => cell.padEnd(widths[i])).join("  ").trimEnd()}
+`);
+  }
+  if (runs.some((entry) => entry.status === "orphaned")) {
+    warn("some locks have no container; run gamecrate stop to clear them");
+  }
+  return Exit.Ok;
+}
+async function stop(args, config, defaults) {
+  const game = requireGame(args, config);
+  const profile = profileOf(args, defaults);
+  const file = join16(instanceDir(args, config, game, profile), ".gamecrate", "lock");
+  const record = await readLock(file);
+  if (record === undefined) {
+    status(`${game} ${profile} is not running`);
+    return Exit.Ok;
+  }
+  const outcome = await stopRun(record, file);
+  if (outcome === "held") {
+    warn(`pid ${record.pid} still holds ${file}; ${record.container} did not stop in time`);
+    return Exit.Refused;
+  }
+  status(outcome === "signalled" ? `stopped ${record.container}` : `cleared the stale lock for ${record.container}`);
+  return Exit.Ok;
+}
+async function attach(args, config, defaults) {
+  const game = requireGame(args, config);
+  const profile = profileOf(args, defaults);
+  return await follow(instanceDir(args, config, game, profile), true, `${game} ${profile}`);
+}
+async function follow(dir, fromStart, what) {
+  const lock = await readLock(join16(dir, ".gamecrate", "lock"));
+  const held = lock !== undefined && isRunning(lock.pid, lock.startedAt);
+  const live = held && await awaitRunLog(dir, lock);
+  const file = currentLog(dir);
+  if (!existsSync8(file)) {
+    throw new GamecrateError(`no captured output for ${what}`, Exit.Usage, file);
+  }
+  return await spawnStatus(tailArgv(file, fromStart, live ? lock.pid : undefined), true);
+}
+async function waitFor(args, config, defaults) {
+  const game = requireGame(args, config);
+  const profile = profileOf(args, defaults);
+  const dir = instanceDir(args, config, game, profile);
+  const record = await awaitExit(dir);
+  if (record === "orphaned") {
+    throw new GamecrateError(`${game} ${profile}: the lock holder is gone and recorded no exit`, Exit.Refused, `run: gamecrate stop ${game} ${profile}`);
+  }
+  if (record === "absent") {
+    throw new GamecrateError(`no run recorded for ${game} ${profile}`, Exit.Usage, dir);
+  }
+  if (args.json)
+    process.stdout.write(`${JSON.stringify(record)}
+`);
+  else
+    status(`${game} ${profile}: ${record.reason} (${record.code})`);
+  return record.code;
+}
 async function build(args, config) {
-  const game2 = requireGame(args, config);
-  await acquireImage(game2, config.games[game2], args.pull ?? "always");
-  status(`${config.games[game2].image.ref} is ready`);
+  const game = requireGame(args, config);
+  await acquireImage(game, config.games[game], args.pull ?? "always");
+  status(`${config.games[game].image.ref} is ready`);
   return Exit.Ok;
 }
 async function configEdit(args) {
   if (args.rest[0] !== "edit")
     throw new GamecrateError("config takes one word: edit", Exit.Usage);
-  const path = defaultConfigPath();
+  const existing = await findGlobalConfig();
+  const path = existing ?? join16(globalConfigDir(), "profiles.yml");
   await mkdir4(dirname5(path), { recursive: true });
-  if (!existsSync7(path))
-    await writeFile4(path, `{
-  "games": {}
-}
+  if (!existsSync8(path)) {
+    await writeFile5(path, `# gamecrate config. see https://github.com/RimWorks/gamecrate
+` + `plugins: []
+` + `games: {}
 `);
+  }
   const editor = process.env.VISUAL ?? process.env.EDITOR;
   if (editor === undefined)
     throw new GamecrateError("no $EDITOR or $VISUAL set", Exit.Usage, path);
@@ -4286,16 +5057,16 @@ async function configEdit(args) {
   return Exit.Ok;
 }
 async function fixPerms(args, config) {
-  const game2 = requireGame(args, config);
+  const game = requireGame(args, config);
   const identity = resolveIdentity(false);
   const found = [];
-  for (const dir of await profileDirs(config, game2, args.profile)) {
-    if (!existsSync7(dir))
+  for (const dir of await profileDirs(config, game, args.profile)) {
+    if (!existsSync8(dir))
       continue;
     found.push(...await detectForeignOwnership(dir, identity.uid, 1e4));
   }
   if (found.length === 0) {
-    status(`${game2}: every path is owned by uid ${identity.uid}`);
+    status(`${game}: every path is owned by uid ${identity.uid}`);
     return Exit.Ok;
   }
   if (args.dryRun || !args.yes) {
@@ -4333,7 +5104,7 @@ async function removeIfEmptyDir(path) {
   const info = await stat4(path).catch(() => null);
   if (info === null || !info.isDirectory())
     return false;
-  const entries = await readdir8(path).catch(() => null);
+  const entries = await readdir9(path).catch(() => null);
   if (entries === null || entries.length > 0)
     return false;
   return rmdir(path).then(() => true, () => false);