@gamecrate/cli 1.0.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;
       }
@@ -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,19 +1953,19 @@ 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;
@@ -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;
@@ -1904,8 +2431,8 @@ function profileDataDir(root, game, profile) {
 async function profileDirs(root, game, profile) {
   if (profile !== undefined)
     return [profileDataDir(root, game, profile)];
-  const dir = join5(expandHome(root.dataRoot), game);
-  return (await readdir2(dir).catch(() => [])).map((name) => join5(dir, name));
+  const dir = join6(expandHome(root.dataRoot), game);
+  return (await readdir3(dir).catch(() => [])).map((name) => join6(dir, name));
 }
 function profileKey(game, name) {
   if (Object.hasOwn(game.profiles, name))
@@ -1914,7 +2441,7 @@ function profileKey(game, name) {
   const direct = Object.keys(game.profiles).find((k) => k.toLowerCase() === lower);
   if (direct !== undefined)
     return direct;
-  return Object.keys(game.profiles).find((k) => (own(game.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)
@@ -1974,7 +2501,7 @@ function expandPaths(config) {
 function expandHome(p) {
   if (p === "~")
     return homedir2();
-  return p.startsWith("~/") ? join5(homedir2(), p.slice(2)) : p;
+  return p.startsWith("~/") ? join6(homedir2(), p.slice(2)) : p;
 }
 
 // src/docker/identity.ts
@@ -1998,155 +2525,7 @@ function hostUserName(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((resolve, reject) => {
-    proc.once("error", reject);
-    proc.once("close", (code) => resolve(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 status = await code;
-    return interrupted ? Exit.Interrupted : status;
-  } finally {
-    process.off("SIGINT", onSignal);
-    process.off("SIGTERM", onSignal);
-    await new Promise((resolve) => sink.end(resolve));
-  }
-}
-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;
-}
-async function tee(stream, sink, mirror) {
-  for await (const chunk of stream) {
-    mirror.write(chunk);
-    sink.write(chunk);
-  }
-}
-
-// src/docker/preflight.ts
+import { basename as basename5, join as join7 } from "node:path";
 var CDI_SPEC = "/etc/cdi/nvidia.yaml";
 async function preflight(plan) {
   const 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"
     });
   }
@@ -2342,15 +2721,40 @@ function firstLine(text) {
   return text.trim().split(`
 `)[0]?.trim() ?? "";
 }
-function message(error) {
-  return error instanceof Error ? error.message : String(error);
+function message(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/docker/window.ts
+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);
 }
-
-// src/docker/window.ts
-import { basename as basename4 } from "node:path";
-import { setTimeout as sleep2 } from "node:timers/promises";
-var WAIT_MS = 180000;
-var POLL_MS = 500;
 async function toplevels() {
   const { code, stdout } = await capture(["wmctrl", "-lx"]);
   if (code === 127)
@@ -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,7 +2859,7 @@ 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(game, plugin) {
   const host = game.gameFiles.host;
@@ -2457,7 +2867,7 @@ async function readInstallVersion(game, plugin) {
     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;
   }
@@ -2483,7 +2893,7 @@ async function readKnownExpansions(game, plugin, warnings) {
       continue;
     let id = null;
     try {
-      id = plugin.parseManifest(await readFile2(join8(dataDir, entry.name, game.manifest.file), "utf8"))?.packageId ?? null;
+      id = plugin.parseManifest(await readFile3(join8(dataDir, entry.name, game.manifest.file), "utf8"))?.packageId ?? null;
     } catch {
       continue;
     }
@@ -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) {
@@ -2690,7 +3100,7 @@ async function buildLocalMods(plan, policy) {
     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`;
@@ -2791,13 +3285,146 @@ async function writeLaunchRecord(plan, image) {
 `, { 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);
@@ -2875,7 +3502,7 @@ function resolveInstance(options) {
   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 }
@@ -2906,21 +3533,21 @@ function derive(requests) {
   return `${slug(first.root)}-${digest.slice(0, 6)}`;
 }
 function slug(root) {
-  const body = basename5(root).toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^[^a-z0-9]+/, "").slice(0, SLUG_LIMIT).replace(/[-._]+$/, "");
+  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;
@@ -2954,8 +3581,8 @@ 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",
@@ -2975,13 +3602,13 @@ async function scanLocalRoot(root, 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,8 +3623,8 @@ 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) });
   }
@@ -3006,7 +3633,7 @@ 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,8 +3643,8 @@ async function scanGameData(game, rootIndex, found) {
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    const dir = join11(data, entry.name);
-    if (!existsSync6(join11(dir, game.manifest.file)))
+    const dir = join12(data, entry.name);
+    if (!existsSync7(join12(dir, game.manifest.file)))
       continue;
     found.push({ dir, kind: "official", rootIndex, linkedWorktree: false });
   }
@@ -3026,7 +3653,7 @@ var CACHE_VERSION = 2;
 function workshopStamp(game) {
   if (game.workshopRoot === null)
     return null;
-  const acf = join11(dirname4(dirname4(resolvePath(expandHome(game.workshopRoot)))), `appworkshop_${game.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}`;
@@ -3036,7 +3663,7 @@ function workshopStamp(game) {
 }
 async function readWorkshopCache(game, stamp) {
   try {
-    const raw = JSON.parse(await readFile4(join11(cacheDir(), `${game}.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;
@@ -3048,7 +3675,7 @@ async function writeWorkshopCache(game, stamp, records) {
   const payload = { version: CACHE_VERSION, stamp, records };
   try {
     await mkdir2(cacheDir(), { recursive: true });
-    await writeFile3(join11(cacheDir(), `${game}.workshop.json`), JSON.stringify(payload));
+    await writeFile4(join12(cacheDir(), `${game}.workshop.json`), JSON.stringify(payload));
   } catch {}
 }
 function toRecord(candidate, manifest, game) {
@@ -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;
@@ -3231,9 +3858,9 @@ async function buildIndex(game, 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({
@@ -3302,11 +3929,11 @@ function byPath(index, raw, game) {
     if (hit)
       return hit;
   }
-  const file = join11(dir, game.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, game);
@@ -3603,11 +4230,11 @@ async function resolvePlan(options) {
     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 = "1.0.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,16 +4504,6 @@ function help(args, config) {
   process.stdout.write(renderHelp(topic, config));
   return Exit.Ok;
 }
-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;
-}
 function instanceDir(args, config, game, profile) {
   const dir = profileDataDir(config, game, profile);
   let spec;
@@ -3790,21 +4515,19 @@ function instanceDir(args, config, game, profile) {
   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) {
+async function run(argv, args, config, plugins, defaults, asShell) {
   const game = requireGame(args, config);
-  const profile = args.profile ?? "modless";
+  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)
@@ -3818,7 +4541,7 @@ async function run(args, config, plugins, asShell) {
     for (const warning of planWarnings(plan))
       warn(warning);
     if (environment.length > 0)
-      return reportEnvironment(environment);
+      reportEnvironment(environment);
     if (!args.printPlan) {
       const what = plan.instance === undefined ? profile : `${profile}/${plan.instance}`;
       status(`${game} ${what}: ${plan.mods.length} mods resolve cleanly`);
@@ -3827,18 +4550,24 @@ async function run(args, config, plugins, asShell) {
   }
   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) {
+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);
@@ -3849,7 +4578,16 @@ run: gamecrate fix-perms ${game} ${profile}`);
   }
   const runDir = openRunLog(plan.logsDirHost);
   plan.runDirHost = runDir;
-  await buildLocalMods(plan, args.build ?? "auto");
+  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);
@@ -3886,7 +4624,9 @@ run: gamecrate fix-perms ${game} ${profile}`);
         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 ${game} ${profile}`);
   }
 }
 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,70 +4708,19 @@ 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 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,
-          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 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(", ")}`);
-      out.push(`  ${profile.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) {
+async function mods(args, config, plugins, defaults) {
   const game = requireGame(args, config);
-  const profile = args.profile ?? "modless";
+  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)
@@ -4061,24 +4750,27 @@ async function doctor(config, plugins) {
   }
   return failed ? Exit.Environment : Exit.Ok;
 }
-async function logs(args, config) {
+async function logs(args, config, defaults) {
   const game = requireGame(args, config);
-  const profile = args.profile ?? "modless";
-  const runs = join14(instanceDir(args, config, game, profile), "logs", "runs");
-  const latest = (await readdir8(runs, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort().at(-1);
+  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 ${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(() => "");
+    const text = await readFile7(join16(runDir, name), "utf8").catch(() => "");
     for (const line of text.split(`
 `)) {
       if (line.length > 0)
@@ -4116,9 +4808,9 @@ function boundStatus(mod) {
     return "OK";
   return mod.hasSources ? "STALE - never built" : "(xml only)";
 }
-async function verify(args, config, plugins) {
+async function verify(args, config, plugins, defaults) {
   const game = requireGame(args, config);
-  const profile = args.profile ?? "modless";
+  const profile = profileOf(args, defaults);
   const { plan, problems } = await resolvePlan({ game, profile, root: config, plugins, args });
   if (problems.length > 0)
     reportProblems(problems);
@@ -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) {
+async function clean(args, config, defaults) {
   const game = requireGame(args, config);
-  const profile = args.profile;
-  if (profile === undefined)
-    throw new GamecrateError("clean needs a profile", Exit.Usage);
+  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 = join14(instanceDir(args, config, game, profile), tier === "logs" ? "logs" : ".stage");
-    await rm2(target, { recursive: true, force: true });
+    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++;
     }
@@ -4246,11 +4936,11 @@ async function clone(args, config) {
   if (src === undefined || dst === undefined) {
     throw new GamecrateError("clone needs a source and a destination profile", Exit.Usage);
   }
-  const from = join14(profileDataDir(config, game, src), "game");
-  const to = join14(profileDataDir(config, game, 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,6 +4950,85 @@ 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 game = requireGame(args, config);
   await acquireImage(game, config.games[game], args.pull ?? "always");
@@ -4269,13 +5038,15 @@ async function build(args, config) {
 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);
@@ -4290,7 +5061,7 @@ async function fixPerms(args, config) {
   const identity = resolveIdentity(false);
   const found = [];
   for (const dir of await profileDirs(config, game, args.profile)) {
-    if (!existsSync7(dir))
+    if (!existsSync8(dir))
       continue;
     found.push(...await detectForeignOwnership(dir, identity.uid, 1e4));
   }
@@ -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);