maestro-manager 0.0.0 → 0.0.1

package/dist/cli.js

@@ -0,0 +1,4458 @@
+#!/usr/bin/env bun
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/simctl/command.ts
+import { execFileSync as execFileSync2 } from "child_process";
+function simctlSync(args) {
+  return runSimctl(args, 30000);
+}
+function simctlSyncTimeout(args, timeoutMs) {
+  return runSimctl(args, timeoutMs);
+}
+function runSimctl(args, timeoutMs) {
+  try {
+    return execFileSync2("xcrun", ["simctl", ...args], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: timeoutMs
+    });
+  } catch (error) {
+    throw new SimctlError(args, exitStatus(error), stderrText(error));
+  }
+}
+function exitStatus(error) {
+  const status = recordValue(error, "status");
+  return typeof status === "number" ? status : 1;
+}
+function stderrText(error) {
+  const stderr = recordValue(error, "stderr");
+  if (typeof stderr === "string")
+    return stderr;
+  if (stderr instanceof Buffer)
+    return stderr.toString("utf8");
+  return String(error);
+}
+function recordValue(value, key) {
+  if (!isRecord(value))
+    return;
+  return value[key];
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+var SimctlError;
+var init_command = __esm(() => {
+  SimctlError = class SimctlError extends Error {
+    args;
+    exitCode;
+    stderr;
+    name = "SimctlError";
+    constructor(args, exitCode, stderr) {
+      super(`xcrun simctl ${args[0] ?? ""} failed (exit ${exitCode}): ${stderr.slice(0, 200)}`);
+      this.args = args;
+      this.exitCode = exitCode;
+      this.stderr = stderr;
+    }
+  };
+});
+
+// src/simctl/devices.ts
+async function listDevices() {
+  return parseDevicesJson(simctlSync(["list", "devices", "--json"]));
+}
+function parseDevicesJson(raw) {
+  const parsed = JSON.parse(raw);
+  if (!isRecord2(parsed))
+    return [];
+  const devicesByRuntime = parsed["devices"];
+  if (!isRuntimeDeviceMap(devicesByRuntime))
+    return [];
+  const devices = [];
+  for (const [runtime, entries] of Object.entries(devicesByRuntime)) {
+    for (const entry of entries) {
+      const device = parseDevice(runtime, entry);
+      if (device !== null)
+        devices.push(device);
+    }
+  }
+  return devices;
+}
+function parseDevice(runtime, entry) {
+  if (!isRecord2(entry))
+    return null;
+  const name = entry["name"];
+  const udid = entry["udid"];
+  const state = entry["state"];
+  if (typeof name !== "string" || typeof udid !== "string" || typeof state !== "string") {
+    return null;
+  }
+  const deviceTypeIdentifier = entry["deviceTypeIdentifier"];
+  return {
+    name,
+    udid,
+    state,
+    deviceTypeIdentifier: typeof deviceTypeIdentifier === "string" ? deviceTypeIdentifier : "",
+    isAvailable: entry["isAvailable"] === true,
+    runtime
+  };
+}
+function isRuntimeDeviceMap(value) {
+  if (!isRecord2(value))
+    return false;
+  return Object.values(value).every(Array.isArray);
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+var init_devices = __esm(() => {
+  init_command();
+});
+
+// src/simctl/runtime-ranking.ts
+function resolveRuntimeFromJson(raw) {
+  const parsed = JSON.parse(raw);
+  if (!isRecord3(parsed))
+    return null;
+  const runtimes = parsed["runtimes"];
+  if (!Array.isArray(runtimes))
+    return null;
+  return resolveRuntimeFromEntries(runtimes);
+}
+function resolveRuntimeFromEntries(runtimes) {
+  let best = null;
+  for (const rt of runtimes) {
+    const ranked = rankRuntime(rt);
+    if (ranked === null || ranked.version.major < 18)
+      continue;
+    if (best === null || compareRuntimeVersion(ranked.version, best.version) > 0) {
+      best = ranked;
+    }
+  }
+  return best?.identifier ?? null;
+}
+function rankRuntime(rt) {
+  if (!isRecord3(rt))
+    return null;
+  const identifier = rt["identifier"];
+  if (typeof identifier !== "string" || rt["isAvailable"] !== true)
+    return null;
+  const identifierVersion = parseIdentifierVersion(identifier);
+  if (identifierVersion === null)
+    return null;
+  const rawVersion = rt["version"];
+  const runtimeVersion = typeof rawVersion === "string" ? parseRuntimeVersion(rawVersion) : null;
+  return {
+    identifier,
+    version: runtimeVersion ?? identifierVersion
+  };
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null;
+}
+function parseRuntimeVersion(version) {
+  const match = RUNTIME_VERSION_PATTERN.exec(version);
+  if (match === null)
+    return null;
+  return parseVersionParts(match);
+}
+function parseIdentifierVersion(identifier) {
+  const match = IOS_RUNTIME_IDENTIFIER_PATTERN.exec(identifier);
+  if (match === null)
+    return null;
+  return parseVersionParts(match);
+}
+function parseVersionParts(match) {
+  const major = match[1];
+  const minor = match[2];
+  const patch = match[3];
+  if (major === undefined || minor === undefined)
+    return null;
+  return {
+    major: Number.parseInt(major, 10),
+    minor: Number.parseInt(minor, 10),
+    patch: patch === undefined ? 0 : Number.parseInt(patch, 10)
+  };
+}
+function compareRuntimeVersion(a, b) {
+  if (a.major !== b.major)
+    return a.major - b.major;
+  if (a.minor !== b.minor)
+    return a.minor - b.minor;
+  return a.patch - b.patch;
+}
+var IOS_RUNTIME_IDENTIFIER_PATTERN, RUNTIME_VERSION_PATTERN;
+var init_runtime_ranking = __esm(() => {
+  IOS_RUNTIME_IDENTIFIER_PATTERN = /^com\.apple\.CoreSimulator\.SimRuntime\.iOS-(\d+)-(\d+)(?:-(\d+))?$/;
+  RUNTIME_VERSION_PATTERN = /^(\d+)\.(\d+)(?:\.(\d+))?$/;
+});
+
+// src/simctl/runtime.ts
+async function resolveRuntime() {
+  const args = ["list", "runtimes", "--json"];
+  const runtime = resolveRuntimeFromJson(simctlSync(args));
+  if (runtime === null) {
+    throw new SimctlError(args, 1, "No available iOS 18+ runtime found. Install one via Xcode > Settings > Platforms.");
+  }
+  return runtime;
+}
+var init_runtime = __esm(() => {
+  init_command();
+  init_runtime_ranking();
+  init_runtime_ranking();
+});
+
+// src/simulatorDisplay.ts
+var DEFAULT_SIMULATOR_DISPLAY_MODE = "headless";
+
+// src/simctl/device-lifecycle.ts
+import { execFileSync as execFileSync3 } from "child_process";
+async function createDevice(name, deviceType, runtime) {
+  const args = ["create", name, deviceType, runtime];
+  const udid = simctlSync(args).trim();
+  if (!udid.match(/^[0-9A-F-]{36}$/i)) {
+    throw new SimctlError(args, 0, `unexpected output - expected a UDID, got: ${udid.slice(0, 80)}`);
+  }
+  return udid;
+}
+async function bootAndWait(udid, displayMode = DEFAULT_SIMULATOR_DISPLAY_MODE) {
+  simctlSyncTimeout(["bootstatus", udid, "-b"], 240000);
+  if (displayMode === "headed") {
+    openSimulatorApp(udid);
+  }
+}
+async function shutdown(udid) {
+  try {
+    simctlSync(["shutdown", udid]);
+  } catch (error) {
+    if (error instanceof SimctlError)
+      return;
+    throw error;
+  }
+}
+async function deleteDevice(udid) {
+  simctlSync(["delete", udid]);
+}
+async function deleteUnavailable() {
+  simctlSync(["delete", "unavailable"]);
+}
+function openSimulatorApp(udid) {
+  try {
+    execFileSync3("open", ["-n", "-a", "Simulator", "--args", "-CurrentDeviceUDID", udid], {
+      encoding: "utf8",
+      stdio: ["ignore", "ignore", "pipe"],
+      timeout: 30000
+    });
+  } catch (error) {
+    throw new SimulatorAppOpenError(udid, exitStatus2(error), stderrText2(error));
+  }
+}
+function exitStatus2(error) {
+  const status = recordValue2(error, "status");
+  return typeof status === "number" ? status : 1;
+}
+function stderrText2(error) {
+  const stderr = recordValue2(error, "stderr");
+  if (typeof stderr === "string")
+    return stderr;
+  if (stderr instanceof Buffer)
+    return stderr.toString("utf8");
+  return String(error);
+}
+function recordValue2(value, key) {
+  if (!isRecord4(value))
+    return;
+  return value[key];
+}
+function isRecord4(value) {
+  return typeof value === "object" && value !== null;
+}
+var SimulatorAppOpenError;
+var init_device_lifecycle = __esm(() => {
+  init_command();
+  SimulatorAppOpenError = class SimulatorAppOpenError extends Error {
+    udid;
+    exitCode;
+    stderr;
+    name = "SimulatorAppOpenError";
+    constructor(udid, exitCode, stderr) {
+      super(`open -a Simulator failed for ${udid} (exit ${exitCode}): ${stderr.slice(0, 200)}`);
+      this.udid = udid;
+      this.exitCode = exitCode;
+      this.stderr = stderr;
+    }
+  };
+});
+
+// src/simctl/app-lifecycle.ts
+import { execFileSync as execFileSync4 } from "child_process";
+import { statSync as statSync7 } from "fs";
+async function install(udid, appPath) {
+  simctlSync(["install", udid, appPath]);
+}
+async function launch(udid, appId) {
+  simctlSync(["launch", udid, appId]);
+}
+async function openUrl(udid, url) {
+  simctlSync(["openurl", udid, url]);
+}
+async function terminate(udid, appId) {
+  try {
+    simctlSync(["terminate", udid, appId]);
+  } catch (error) {
+    if (error instanceof SimctlError)
+      return;
+    throw error;
+  }
+}
+async function listInstalledApps(udid) {
+  return parseAppBundleIds(simctlSync(["listapps", udid]));
+}
+async function hasApp(udid, appId) {
+  const apps = await listInstalledApps(udid);
+  return apps.includes(appId);
+}
+async function installedAppMtime(udid, appId) {
+  try {
+    const containerPath = simctlSync(["get_app_container", udid, appId]).trim();
+    if (containerPath.length === 0)
+      return null;
+    return statSync7(containerPath).mtimeMs;
+  } catch (error) {
+    if (error instanceof Error)
+      return null;
+    throw error;
+  }
+}
+function parseAppBundleIds(plistText) {
+  try {
+    return bundleIdsFromJsonText(plistText);
+  } catch (error) {
+    if (!(error instanceof Error))
+      throw error;
+  }
+  try {
+    const jsonText = execFileSync4("plutil", ["-convert", "json", "-o", "-", "-"], {
+      input: plistText,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return bundleIdsFromJsonText(jsonText);
+  } catch (error) {
+    if (error instanceof Error)
+      return bundleIdsFromPlistStrings(plistText);
+    throw error;
+  }
+}
+function bundleIdsFromJsonText(jsonText) {
+  const parsed = JSON.parse(jsonText);
+  if (!isRecord5(parsed))
+    return [];
+  const bundleIds = [];
+  for (const entry of Object.values(parsed)) {
+    const bundleId = bundleIdFromEntry(entry);
+    if (bundleId !== null)
+      bundleIds.push(bundleId);
+  }
+  return bundleIds;
+}
+function bundleIdFromEntry(entry) {
+  if (!isRecord5(entry))
+    return null;
+  const bundleId = entry["CFBundleIdentifier"];
+  return typeof bundleId === "string" ? bundleId : null;
+}
+function bundleIdsFromPlistStrings(plistText) {
+  const matches = plistText.match(/<string>([\w.+-]+)<\/string>/g) ?? [];
+  return matches.map((match) => match.replace(/<\/?string>/g, "")).filter((value) => value.includes("."));
+}
+function isRecord5(value) {
+  return typeof value === "object" && value !== null;
+}
+var init_app_lifecycle = __esm(() => {
+  init_command();
+});
+
+// src/simctl/recording.ts
+import { spawn } from "child_process";
+async function recordVideoStart(udid, outPath) {
+  const simctlArgs = ["io", udid, "recordVideo", "--codec", "h264", outPath];
+  const proc = spawn("xcrun", ["simctl", ...simctlArgs], {
+    stdio: "ignore",
+    detached: false
+  });
+  const pid = proc.pid;
+  if (pid === undefined) {
+    throw new SimctlError(simctlArgs, 1, "recordVideo did not start a process");
+  }
+  return {
+    pid,
+    stop: async () => {
+      try {
+        process.kill(pid, "SIGINT");
+      } catch (error) {
+        if (!(error instanceof Error))
+          throw error;
+      }
+      await new Promise((resolve3) => {
+        const timeout = setTimeout(resolve3, 2000);
+        const finish = () => {
+          clearTimeout(timeout);
+          resolve3();
+        };
+        proc.once("exit", finish);
+        proc.once("error", finish);
+      });
+    }
+  };
+}
+var init_recording = __esm(() => {
+  init_command();
+});
+
+// src/simctl.ts
+var exports_simctl = {};
+__export(exports_simctl, {
+  terminate: () => terminate,
+  shutdown: () => shutdown,
+  resolveRuntime: () => resolveRuntime,
+  recordVideoStart: () => recordVideoStart,
+  openUrl: () => openUrl,
+  listInstalledApps: () => listInstalledApps,
+  listDevices: () => listDevices,
+  launch: () => launch,
+  installedAppMtime: () => installedAppMtime,
+  install: () => install,
+  hasApp: () => hasApp,
+  deleteUnavailable: () => deleteUnavailable,
+  deleteDevice: () => deleteDevice,
+  createDevice: () => createDevice,
+  bootAndWait: () => bootAndWait,
+  SimctlError: () => SimctlError
+});
+var init_simctl = __esm(() => {
+  init_command();
+  init_devices();
+  init_runtime();
+  init_device_lifecycle();
+  init_app_lifecycle();
+  init_recording();
+});
+
+// src/cli.ts
+import { resolve as resolve3 } from "path";
+
+// src/config.ts
+import { readFileSync, existsSync } from "fs";
+import { join, dirname, resolve, isAbsolute } from "path";
+import { homedir } from "os";
+var CONFIG_FILENAME = "maestro-manager.config.json";
+var POOL_MAX_CAP = 8;
+var SAFE_POOL_PREFIX_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+
+class ConfigError extends Error {
+  key;
+  constructor(key, message) {
+    super(`maestro-manager config: [${key}] ${message}`);
+    this.key = key;
+    this.name = "ConfigError";
+  }
+}
+function expandTilde(p) {
+  return p === "~" || p.startsWith("~/") ? homedir() + p.slice(1) : p;
+}
+function expandAndResolve(p, configDir) {
+  const expanded = expandTilde(p);
+  if (isAbsolute(expanded))
+    return expanded;
+  return resolve(configDir, expanded);
+}
+function findConfigFile(startDir) {
+  let current = resolve(startDir);
+  for (;; ) {
+    const candidate = join(current, CONFIG_FILENAME);
+    if (existsSync(candidate))
+      return candidate;
+    const parent = dirname(current);
+    if (parent === current)
+      return null;
+    current = parent;
+  }
+}
+function resolveConfigPath(startDir, explicitPath) {
+  if (explicitPath !== undefined && explicitPath !== "") {
+    const p = expandAndResolve(explicitPath, startDir);
+    if (!existsSync(p)) {
+      throw new ConfigError(CONFIG_FILENAME, `--config path does not exist: ${p}`);
+    }
+    return p;
+  }
+  const envPath = process.env["MAESTRO_MANAGER_CONFIG"];
+  if (envPath !== undefined && envPath !== "") {
+    const p = expandAndResolve(envPath, startDir);
+    if (!existsSync(p)) {
+      throw new ConfigError(CONFIG_FILENAME, `MAESTRO_MANAGER_CONFIG points to a missing file: ${p}`);
+    }
+    return p;
+  }
+  const found = findConfigFile(startDir);
+  if (found === null) {
+    throw new ConfigError(CONFIG_FILENAME, `not found. Pass --config <path>, set MAESTRO_MANAGER_CONFIG=<path>, or run from a ` + `directory at/under one containing ${CONFIG_FILENAME} (searched ${startDir} up to /).`);
+  }
+  return found;
+}
+function describeValueType(val) {
+  if (val === null)
+    return "null";
+  if (Array.isArray(val))
+    return "array";
+  if (typeof val === "number") {
+    return Number.isFinite(val) ? `number ${val}` : `non-finite number ${String(val)}`;
+  }
+  return typeof val;
+}
+function isPlainObject(val) {
+  if (val === null || typeof val !== "object" || Array.isArray(val))
+    return false;
+  const prototype = Object.getPrototypeOf(val);
+  return prototype === Object.prototype || prototype === null;
+}
+function assertObject(val, key) {
+  if (!isPlainObject(val)) {
+    throw new ConfigError(key, `must be a plain object (got ${describeValueType(val)})`);
+  }
+  return val;
+}
+function assertString(val, key) {
+  if (typeof val !== "string") {
+    throw new ConfigError(key, `must be a string (got ${describeValueType(val)})`);
+  }
+  return val;
+}
+function assertSafePoolPrefix(prefix) {
+  if (SAFE_POOL_PREFIX_PATTERN.test(prefix))
+    return prefix;
+  throw new ConfigError("pool.prefix", "must be a single path segment starting with a letter or number and containing only letters, numbers, dots, underscores, and hyphens");
+}
+function assertPositiveInteger(val, key) {
+  if (typeof val !== "number" || !Number.isFinite(val) || !Number.isInteger(val) || val < 1) {
+    throw new ConfigError(key, `must be a finite positive integer (got ${describeValueType(val)})`);
+  }
+  return val;
+}
+function assertStringArray(val, key) {
+  if (!Array.isArray(val) || val.some((v) => typeof v !== "string")) {
+    throw new ConfigError(key, `must be an array of strings`);
+  }
+  return val;
+}
+function validatePool(raw) {
+  const obj = assertObject(raw, "pool");
+  const prefix = assertSafePoolPrefix(assertString(obj["prefix"], "pool.prefix"));
+  const deviceType = assertString(obj["deviceType"], "pool.deviceType");
+  const dflt = assertPositiveInteger(obj["default"], "pool.default");
+  const max = assertPositiveInteger(obj["max"], "pool.max");
+  if (max > POOL_MAX_CAP) {
+    throw new ConfigError("pool.max", `must be <= ${POOL_MAX_CAP} (got ${max}); pool.max above 4 requires downstream backend stability proof`);
+  }
+  if (max < dflt) {
+    throw new ConfigError("pool.max", `must be >= pool.default (${dflt}), but got ${max}`);
+  }
+  return { prefix, deviceType, default: dflt, max };
+}
+function validateApp(raw) {
+  const obj = assertObject(raw, "app");
+  const appId = assertString(obj["appId"], "app.appId");
+  const searchDirs = assertStringArray(obj["searchDirs"], "app.searchDirs");
+  const result = { appId, searchDirs };
+  if (obj["path"] !== undefined) {
+    result.path = assertString(obj["path"], "app.path");
+  }
+  if (obj["glob"] !== undefined) {
+    result.glob = assertString(obj["glob"], "app.glob");
+  }
+  return result;
+}
+function validateJava(raw) {
+  const obj = assertObject(raw, "java");
+  const home = obj["home"];
+  if (home !== null && typeof home !== "string") {
+    throw new ConfigError("java.home", `must be a string or null (got ${describeValueType(home)})`);
+  }
+  const autodetect = assertStringArray(obj["autodetect"], "java.autodetect");
+  return { home, autodetect };
+}
+function validateHooks(raw) {
+  const obj = assertObject(raw, "hooks");
+  const result = {};
+  if (obj["pruneAccounts"] !== undefined) {
+    result.pruneAccounts = assertString(obj["pruneAccounts"], "hooks.pruneAccounts");
+  }
+  return result;
+}
+function loadConfig(startDir, explicitPath) {
+  const configPath = resolveConfigPath(startDir, explicitPath);
+  const configDir = dirname(configPath);
+  let parsed;
+  try {
+    const text = readFileSync(configPath, { encoding: "utf8" });
+    parsed = JSON.parse(text);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new ConfigError(CONFIG_FILENAME, `failed to parse: ${message}`);
+  }
+  const raw = assertObject(parsed, CONFIG_FILENAME);
+  for (const key of [
+    "pool",
+    "app",
+    "flowsDir",
+    "warmupDeepLink",
+    "java",
+    "recordingsDir",
+    "hooks"
+  ]) {
+    if (raw[key] === undefined) {
+      throw new ConfigError(key, `is required but missing from ${configPath}`);
+    }
+  }
+  const pool = validatePool(raw["pool"]);
+  const app = validateApp(raw["app"]);
+  const java = validateJava(raw["java"]);
+  const hooks = validateHooks(raw["hooks"]);
+  const rawFlowsDir = assertString(raw["flowsDir"], "flowsDir");
+  const warmupDeepLink = assertString(raw["warmupDeepLink"], "warmupDeepLink");
+  const rawRecordingsDir = assertString(raw["recordingsDir"], "recordingsDir");
+  const flowsDir = expandAndResolve(rawFlowsDir, configDir);
+  const recordingsDir = expandAndResolve(rawRecordingsDir, configDir);
+  const expandedApp = {
+    ...app,
+    searchDirs: app.searchDirs.map((d) => expandAndResolve(d, configDir))
+  };
+  return {
+    pool,
+    app: expandedApp,
+    flowsDir,
+    warmupDeepLink,
+    java,
+    recordingsDir,
+    hooks
+  };
+}
+
+// src/commands/up.ts
+import { mkdirSync as mkdirSync8 } from "fs";
+
+// src/state.ts
+import { readFileSync as readFileSync2, writeFileSync, renameSync, mkdirSync } from "fs";
+import { dirname as dirname2, join as join2, resolve as resolve2, relative, isAbsolute as isAbsolute2 } from "path";
+import { homedir as homedir2 } from "os";
+var MANAGER_STATE_DIR = ".maestro-manager";
+
+class StatePathError extends Error {
+  constructor(root, base) {
+    super(`maestro-manager state root must stay under ${base}: ${root}`);
+    this.name = "StatePathError";
+  }
+}
+function managerStateBase() {
+  return resolve2(homedir2(), MANAGER_STATE_DIR);
+}
+function assertPoolRootContained(root) {
+  const base = managerStateBase();
+  const resolvedRoot = resolve2(root);
+  const relativeRoot = relative(base, resolvedRoot);
+  if (relativeRoot === "" || relativeRoot.startsWith("..") || isAbsolute2(relativeRoot)) {
+    throw new StatePathError(resolvedRoot, base);
+  }
+  return resolvedRoot;
+}
+function poolRoot(config) {
+  return assertPoolRootContained(resolve2(managerStateBase(), config.pool.prefix));
+}
+function configSnapshotPath(config) {
+  return join2(poolRoot(config), "config-snapshot.json");
+}
+function poolLockDir(config) {
+  return join2(poolRoot(config), "locks", "pool.lock");
+}
+function simDir(config, simName) {
+  return join2(poolRoot(config), "sims", simName);
+}
+function simUdidPath(config, simName) {
+  return join2(simDir(config, simName), "udid");
+}
+function simLastUsedPath(config, simName) {
+  return join2(simDir(config, simName), "lastused");
+}
+function simLeaseDir(config, simName) {
+  return join2(simDir(config, simName), "lease");
+}
+function simLeaseRecordPath(config, simName) {
+  return join2(simLeaseDir(config, simName), "record.json");
+}
+function fullSuiteReservationDir(config) {
+  return join2(poolRoot(config), "reservation");
+}
+function fullSuiteReservationRecordPath(config) {
+  return join2(fullSuiteReservationDir(config), "record.json");
+}
+function waiterDir(config, runId) {
+  return join2(poolRoot(config), "waiters", runId);
+}
+function waiterTicketPath(config, runId) {
+  return join2(waiterDir(config, runId), "ticket.json");
+}
+function runDir(config, runId) {
+  return join2(poolRoot(config), "runs", runId);
+}
+function runRecordPath(config, runId) {
+  return join2(runDir(config, runId), "run.json");
+}
+function runFlowLogPath(config, runId, flow) {
+  return join2(runDir(config, runId), `${flow}.log`);
+}
+function runsIndexPath(config) {
+  return join2(poolRoot(config), "runs", "index.json");
+}
+function atomicWriteJson(filePath, value) {
+  const dir = dirname2(filePath);
+  mkdirSync(dir, { recursive: true });
+  const rand = Math.floor(Math.random() * 16777215).toString(16).padStart(6, "0");
+  const tmpPath = `${filePath}.tmp.${process.pid}.${rand}`;
+  const json = JSON.stringify(value, null, 2);
+  writeFileSync(tmpPath, json, { encoding: "utf8" });
+  renameSync(tmpPath, filePath);
+}
+function readJsonOrNull(filePath) {
+  try {
+    const raw = readFileSync2(filePath, { encoding: "utf8" });
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+// src/pool/reconcile.ts
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, statSync } from "fs";
+async function reconcile(config, simctl) {
+  const devices = await simctl.listDevices();
+  const prefix = config.pool.prefix;
+  const poolDevices = devices.filter((d) => d.name.startsWith(`${prefix}-`));
+  const slots = [];
+  for (const device of poolDevices) {
+    const simName = device.name;
+    const udid = device.udid;
+    const udidPath = simUdidPath(config, simName);
+    try {
+      mkdirSync2(simDir(config, simName), { recursive: true });
+      writeFileSync2(udidPath, udid, { encoding: "utf8" });
+    } catch (error) {
+      if (!(error instanceof Error)) {
+        throw error;
+      }
+    }
+    slots.push({
+      simName,
+      udid,
+      state: device.state,
+      leased: isDirPresent(simLeaseDir(config, simName))
+    });
+  }
+  const freeSlots = slots.filter((slot) => !slot.leased).map((slot) => ({ simName: slot.simName, udid: slot.udid }));
+  return {
+    slots,
+    freeSlots,
+    leasedCount: slots.filter((slot) => slot.leased).length
+  };
+}
+function isDirPresent(dirPath) {
+  try {
+    const st = statSync(dirPath);
+    return st.isDirectory();
+  } catch {
+    return false;
+  }
+}
+// src/pool/slot-creation.ts
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
+async function createGapSim(config, index, simctl) {
+  const simName = `${config.pool.prefix}-${index}`;
+  const devices = await simctl.listDevices();
+  const existing = devices.find((device) => device.name === simName);
+  const udid = existing?.udid ?? await simctl.createDevice(simName, resolveDeviceTypeId(config.pool.deviceType), await simctl.resolveRuntime());
+  mkdirSync3(simDir(config, simName), { recursive: true });
+  writeFileSync3(simUdidPath(config, simName), udid, { encoding: "utf8" });
+  return { simName, udid };
+}
+function resolveDeviceTypeId(deviceType) {
+  if (deviceType.startsWith("com.apple.")) {
+    return deviceType;
+  }
+  return `com.apple.CoreSimulator.SimDeviceType.${deviceType}`;
+}
+// src/pool/lease-selection.ts
+import { statSync as statSync5 } from "fs";
+
+// src/fairness.ts
+import { readdirSync, mkdirSync as mkdirSync4, statSync as statSync2, rmSync } from "fs";
+import { join as join3 } from "path";
+
+// src/liveness.ts
+import { execFileSync } from "child_process";
+var HEARTBEAT_TTL_MS = 180000;
+var PROBE_RETRY_ATTEMPTS = 3;
+var PROBE_RETRY_BACKOFF_MS = 5;
+var LIVE_OWNER = { kind: "live" };
+function retrySync(fn, fallback, attempts = PROBE_RETRY_ATTEMPTS) {
+  for (let i = 0;i < attempts; i++) {
+    try {
+      return fn();
+    } catch {
+      if (i < attempts - 1) {
+        const end = Date.now() + PROBE_RETRY_BACKOFF_MS;
+        while (Date.now() < end) {}
+      }
+    }
+  }
+  return fallback;
+}
+function pidIsDead(pid) {
+  if (pid <= 0)
+    return true;
+  try {
+    process.kill(pid, 0);
+    return false;
+  } catch (err) {
+    if (!(err instanceof Error))
+      return false;
+    const code = errnoCode(err);
+    if (code === "EPERM") {
+      return false;
+    }
+    if (code === "ESRCH") {
+      return true;
+    }
+    return false;
+  }
+}
+function processStartTime(pid) {
+  if (pid <= 0)
+    return null;
+  return retrySync(() => {
+    const output = execFileSync("ps", ["-o", "lstart=", "-p", String(pid)], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      env: { ...process.env, TZ: "UTC", LC_ALL: "C" }
+    });
+    const trimmed = output.trim();
+    return trimmed.length > 0 ? trimmed : null;
+  }, null, PROBE_RETRY_ATTEMPTS);
+}
+function machineBootId() {
+  return retrySync(() => {
+    const output = execFileSync("sysctl", ["-n", "kern.bootsessionuuid"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const uuid = output.trim();
+    if (uuid.length > 0)
+      return uuid;
+    throw new Error("empty sysctl output");
+  }, "", PROBE_RETRY_ATTEMPTS);
+}
+function ownerLiveness(record) {
+  try {
+    if (pidIsDead(record.ownerPid)) {
+      return { kind: "stale", reason: "pid-dead" };
+    }
+    const currentBoot = machineBootId();
+    if (hasKnownIdentity(record.bootId) && currentBoot !== "" && currentBoot !== record.bootId) {
+      return { kind: "stale", reason: "boot-id-mismatch" };
+    }
+    const startTime = processStartTime(record.ownerPid);
+    if (hasKnownIdentity(record.ownerStart) && startTime !== null && startTime !== record.ownerStart) {
+      return { kind: "stale", reason: "owner-start-mismatch" };
+    }
+    return LIVE_OWNER;
+  } catch {
+    return LIVE_OWNER;
+  }
+}
+function isOwnerLive(record) {
+  return ownerLiveness(record).kind === "live";
+}
+function ownerIdentitiesMatch(left, right) {
+  if (left.ownerPid !== right.ownerPid) {
+    return false;
+  }
+  if (hasKnownIdentity(left.ownerStart) && hasKnownIdentity(right.ownerStart) && left.ownerStart !== right.ownerStart) {
+    return false;
+  }
+  if (hasKnownIdentity(left.bootId) && hasKnownIdentity(right.bootId) && left.bootId !== right.bootId) {
+    return false;
+  }
+  return true;
+}
+function hasKnownIdentity(value) {
+  return value !== undefined && value !== null && value !== "";
+}
+function errnoCode(error) {
+  if (typeof error !== "object" || error === null || !("code" in error))
+    return;
+  const { code } = error;
+  return typeof code === "string" ? code : undefined;
+}
+function isHeartbeatStale(record, now = Date.now(), ttlMs = HEARTBEAT_TTL_MS) {
+  try {
+    const heartbeat = Date.parse(record.heartbeatAt);
+    if (Number.isNaN(heartbeat)) {
+      return true;
+    }
+    return now - heartbeat > ttlMs;
+  } catch {
+    return true;
+  }
+}
+
+// src/fairness.ts
+function writeTicket(config, runId, ticket) {
+  const ticketPath = waiterTicketPath(config, runId);
+  mkdirSync4(waiterDir(config, runId), { recursive: true });
+  const persistedTicket = {
+    ...ticket,
+    ownerStart: ticket.ownerStart ?? processStartTime(ticket.ownerPid) ?? "",
+    bootId: ticket.bootId ?? machineBootId()
+  };
+  atomicWriteJson(ticketPath, persistedTicket);
+}
+function removeTicket(config, runId) {
+  try {
+    rmSync(waiterDir(config, runId), { recursive: true, force: true });
+  } catch (error) {
+    if (!(error instanceof Error)) {
+      throw error;
+    }
+  }
+}
+function heldLeaseCount(config, agent) {
+  try {
+    const simsDir = join3(poolRoot(config), "sims");
+    let entries;
+    try {
+      entries = readdirSync(simsDir);
+    } catch {
+      return 0;
+    }
+    let count = 0;
+    for (const simName of entries) {
+      const leaseDirPath = simLeaseDir(config, simName);
+      const recordPath = simLeaseRecordPath(config, simName);
+      let dirExists = false;
+      try {
+        dirExists = statSync2(leaseDirPath).isDirectory();
+      } catch {
+        continue;
+      }
+      if (!dirExists)
+        continue;
+      const record = readJsonOrNull(recordPath);
+      if (record === null)
+        continue;
+      if (record.worktree !== agent)
+        continue;
+      if (!isOwnerLive(record))
+        continue;
+      count++;
+    }
+    return count;
+  } catch {
+    return 0;
+  }
+}
+function rankWaiters(config) {
+  try {
+    const waitersDir = join3(poolRoot(config), "waiters");
+    let runIds;
+    try {
+      runIds = readdirSync(waitersDir);
+    } catch {
+      return [];
+    }
+    const live = [];
+    for (const runId of runIds) {
+      const ticketPath = waiterTicketPath(config, runId);
+      const ticket = readJsonOrNull(ticketPath);
+      if (ticket === null)
+        continue;
+      if (!isOwnerLive(ticket))
+        continue;
+      live.push(ticket);
+    }
+    live.sort((a, b) => {
+      const aHeld = heldLeaseCount(config, a.agent);
+      const bHeld = heldLeaseCount(config, b.agent);
+      if (aHeld !== bHeld)
+        return aHeld - bHeld;
+      const aTime = Date.parse(a.enqueuedAt);
+      const bTime = Date.parse(b.enqueuedAt);
+      return aTime - bTime;
+    });
+    return live;
+  } catch {
+    return [];
+  }
+}
+function isBestRankedFor(config, runId) {
+  try {
+    const myTicketPath = waiterTicketPath(config, runId);
+    const myTicket = readJsonOrNull(myTicketPath);
+    if (myTicket === null)
+      return false;
+    if (!isOwnerLive(myTicket))
+      return false;
+    const ranked = rankWaiters(config);
+    if (ranked.length === 0)
+      return false;
+    const top = ranked[0];
+    if (top === undefined)
+      return false;
+    return top.agent === myTicket.agent && ownerIdentitiesMatch(top, myTicket);
+  } catch {
+    return false;
+  }
+}
+
+// src/leaseReservation.ts
+import { mkdirSync as mkdirSync6, readdirSync as readdirSync2, rmSync as rmSync5, statSync as statSync4 } from "fs";
+import { join as join7 } from "path";
+
+// src/lock/with-pool-lock.ts
+import { mkdirSync as mkdirSync5, rmSync as rmSync3 } from "fs";
+import { join as join6 } from "path";
+
+// src/lock/contracts.ts
+var INITIAL_BACKOFF_MS = 50;
+var MAX_BACKOFF_MS = 500;
+var LOCK_TIMEOUT_MS = 30000;
+var LOCK_ACQUIRE_ORPHAN_GRACE_MS = 5000;
+
+// src/lock/owner-record.ts
+import { writeFileSync as writeFileSync4 } from "fs";
+import { join as join4 } from "path";
+function writeMinimalOwnerRecord(lockDir) {
+  const ownerPath = join4(lockDir, "owner.json");
+  const record = {
+    pid: process.pid,
+    acquiredAt: Date.now()
+  };
+  writeFileSync4(ownerPath, JSON.stringify(record, null, 2), { encoding: "utf8", flag: "wx" });
+}
+function backfillOwnerRecord(lockDir) {
+  const ownerPath = join4(lockDir, "owner.json");
+  const existing = readJsonOrNull(ownerPath);
+  const acquiredAt = existing !== null && Number.isFinite(Number(existing.acquiredAt)) ? Number(existing.acquiredAt) : Date.now();
+  const record = {
+    pid: process.pid,
+    acquiredAt,
+    ownerStart: processStartTime(process.pid),
+    bootId: machineBootId()
+  };
+  writeFileSync4(ownerPath, JSON.stringify(record, null, 2), { encoding: "utf8" });
+}
+function ownerRecordMatchesPid(lockDir, myPid) {
+  const ownerPath = join4(lockDir, "owner.json");
+  const owner = readJsonOrNull(ownerPath);
+  return owner !== null && owner.pid === myPid;
+}
+
+// src/lock/steal-dead-owner.ts
+import { rmSync as rmSync2, renameSync as renameSync2, statSync as statSync3 } from "fs";
+import { randomUUID } from "crypto";
+import { join as join5 } from "path";
+
+// src/lock/liveness.ts
+function isLockOwnerLive(owner) {
+  try {
+    if (pidIsDead(owner.pid)) {
+      return false;
+    }
+    const currentBoot = machineBootId();
+    if (owner.bootId !== undefined && owner.bootId !== "" && currentBoot !== "" && currentBoot !== owner.bootId) {
+      return false;
+    }
+    if (owner.ownerStart !== undefined && owner.ownerStart !== null && owner.ownerStart !== "") {
+      const startTime = processStartTime(owner.pid);
+      if (startTime !== null && startTime !== owner.ownerStart) {
+        return false;
+      }
+    }
+    return true;
+  } catch {
+    return true;
+  }
+}
+
+// src/lock/steal-dead-owner.ts
+function tryStealDeadLock(lockDir, myPid) {
+  const ownerPath = join5(lockDir, "owner.json");
+  const owner = readJsonOrNull(ownerPath);
+  if (owner === null) {
+    const ageMs = lockDirAgeMs(lockDir, null);
+    if (ageMs !== null && ageMs > LOCK_ACQUIRE_ORPHAN_GRACE_MS) {
+      return atomicSteal(lockDir, myPid);
+    }
+    return false;
+  }
+  if (isLockOwnerLive(owner)) {
+    return false;
+  }
+  return atomicSteal(lockDir, myPid);
+}
+function atomicSteal(lockDir, myPid) {
+  const tombstone = `${lockDir}.dead.${myPid}.${randomUUID()}`;
+  try {
+    renameSync2(lockDir, tombstone);
+  } catch (renameErr) {
+    if (errnoCode2(renameErr) === "ENOENT") {
+      return true;
+    }
+    if (!(renameErr instanceof Error)) {
+      throw renameErr;
+    }
+    return false;
+  }
+  try {
+    rmSync2(tombstone, { recursive: true, force: true });
+  } catch (error) {
+    if (!(error instanceof Error)) {
+      throw error;
+    }
+  }
+  return true;
+}
+function lockDirAgeMs(lockDir, owner) {
+  if (owner !== null) {
+    const acquired = Number(owner.acquiredAt);
+    if (Number.isFinite(acquired) && acquired > 0) {
+      return Date.now() - acquired;
+    }
+  }
+  try {
+    const stat = statSync3(lockDir);
+    return Date.now() - stat.mtimeMs;
+  } catch {
+    return null;
+  }
+}
+function errnoCode2(error) {
+  if (typeof error !== "object" || error === null || !("code" in error)) {
+    return;
+  }
+  const { code } = error;
+  return typeof code === "string" ? code : undefined;
+}
+
+// src/lock/backoff.ts
+function waitForNextLockAttempt(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+
+// src/lock/with-pool-lock.ts
+async function withPoolLock(config, fn) {
+  const lockDir = poolLockDir(config);
+  const deadline = Date.now() + LOCK_TIMEOUT_MS;
+  let backoff = INITIAL_BACKOFF_MS;
+  const ownedByUs = () => ownerRecordMatchesPid(lockDir, process.pid);
+  try {
+    mkdirSync5(join6(lockDir, ".."), { recursive: true });
+  } catch (error) {
+    if (!(error instanceof Error)) {
+      throw error;
+    }
+  }
+  await acquirePoolLock({ lockDir, deadline, backoff, ownedByUs });
+  let outcome;
+  try {
+    outcome = { kind: "fulfilled", value: await fn() };
+  } catch (error) {
+    outcome = error instanceof Error ? { kind: "rejected-error", error } : { kind: "rejected-unknown", error };
+  }
+  let unexpectedReleaseError = null;
+  try {
+    if (ownedByUs()) {
+      rmSync3(lockDir, { recursive: true, force: true });
+    }
+  } catch (error) {
+    if (!(error instanceof Error)) {
+      unexpectedReleaseError = { error };
+    }
+  }
+  if (outcome.kind !== "fulfilled") {
+    throw outcome.error;
+  }
+  if (unexpectedReleaseError !== null) {
+    throw unexpectedReleaseError.error;
+  }
+  return outcome.value;
+}
+function tryAcquireLock(lockDir) {
+  try {
+    mkdirSync5(lockDir, { recursive: false });
+    return true;
+  } catch (err) {
+    const code = errnoCode3(err);
+    if (code === "EEXIST") {
+      return false;
+    }
+    if (code === "ENOENT") {
+      try {
+        mkdirSync5(join6(lockDir, ".."), { recursive: true });
+        mkdirSync5(lockDir, { recursive: false });
+        return true;
+      } catch (retryError) {
+        if (!(retryError instanceof Error)) {
+          throw retryError;
+        }
+        return false;
+      }
+    }
+    throw err;
+  }
+}
+async function acquirePoolLock(state) {
+  if (tryAcquireLock(state.lockDir)) {
+    try {
+      writeMinimalOwnerRecord(state.lockDir);
+      backfillOwnerRecord(state.lockDir);
+    } catch (error) {
+      if (!(error instanceof Error)) {
+        throw error;
+      }
+      if (state.ownedByUs()) {
+        try {
+          rmSync3(state.lockDir, { recursive: true, force: true });
+        } catch (releaseError) {
+          if (!(releaseError instanceof Error)) {
+            throw releaseError;
+          }
+        }
+      }
+      return retryLockAcquire(state);
+    }
+    if (state.ownedByUs()) {
+      return;
+    }
+    return retryLockAcquire(state);
+  }
+  if (tryStealDeadLock(state.lockDir, process.pid)) {
+    return acquirePoolLock(state);
+  }
+  return retryLockAcquire(state);
+}
+async function retryLockAcquire(state) {
+  if (Date.now() >= state.deadline) {
+    throw new Error(`withPoolLock: timed out after ${LOCK_TIMEOUT_MS}ms waiting for ${state.lockDir}`);
+  }
+  await waitForNextLockAttempt(state.backoff);
+  return acquirePoolLock({
+    ...state,
+    backoff: Math.min(state.backoff * 2, MAX_BACKOFF_MS)
+  });
+}
+function errnoCode3(error) {
+  if (typeof error !== "object" || error === null || !("code" in error)) {
+    return;
+  }
+  const { code } = error;
+  return typeof code === "string" ? code : undefined;
+}
+// src/leaseReclaim.ts
+import { rmSync as rmSync4 } from "fs";
+async function reclaimIfStale(config, simName) {
+  return withPoolLock(config, () => reclaimUnderLock(config, simName));
+}
+function reclaimUnderLock(config, simName) {
+  const leaseDir = simLeaseDir(config, simName);
+  const recordPath = simLeaseRecordPath(config, simName);
+  const record1 = readJsonOrNull(recordPath);
+  if (record1 === null) {
+    return false;
+  }
+  const shouldReclaim = !isOwnerLive(record1) && isHeartbeatStale(record1) && pidIsDead(record1.maestroPid);
+  if (!shouldReclaim) {
+    return false;
+  }
+  const record2 = readJsonOrNull(recordPath);
+  if (record2 === null) {
+    return false;
+  }
+  if (!ownerIdentitiesMatch(record1, record2)) {
+    return false;
+  }
+  const stillShouldReclaim = !isOwnerLive(record2) && isHeartbeatStale(record2) && pidIsDead(record2.maestroPid);
+  if (!stillShouldReclaim) {
+    return false;
+  }
+  try {
+    rmSync4(leaseDir, { recursive: true, force: true });
+    return true;
+  } catch (error) {
+    if (error instanceof Error) {
+      return false;
+    }
+    throw error;
+  }
+}
+function reclaimFullSuiteReservationUnderLock(config) {
+  const reservationDir = fullSuiteReservationDir(config);
+  const recordPath = fullSuiteReservationRecordPath(config);
+  const record1 = readJsonOrNull(recordPath);
+  if (record1 === null) {
+    return false;
+  }
+  if (!isFullSuiteReservationReclaimable(record1)) {
+    return false;
+  }
+  const record2 = readJsonOrNull(recordPath);
+  if (record2 === null) {
+    return false;
+  }
+  if (!reservationRecordsMatch(record1, record2)) {
+    return false;
+  }
+  if (!isFullSuiteReservationReclaimable(record2)) {
+    return false;
+  }
+  try {
+    rmSync4(reservationDir, { recursive: true, force: true });
+    return true;
+  } catch (error) {
+    if (error instanceof Error) {
+      return false;
+    }
+    throw error;
+  }
+}
+function reapOrphanUnderLock(config, simName, killMaestro) {
+  const leaseDir = simLeaseDir(config, simName);
+  const recordPath = simLeaseRecordPath(config, simName);
+  const record1 = readJsonOrNull(recordPath);
+  if (record1 === null) {
+    return false;
+  }
+  const isOrphan = !isOwnerLive(record1) && isHeartbeatStale(record1) && record1.maestroPid > 0 && !pidIsDead(record1.maestroPid);
+  if (!isOrphan) {
+    return false;
+  }
+  killMaestro(record1.maestroPid);
+  const record2 = readJsonOrNull(recordPath);
+  if (record2 === null) {
+    return false;
+  }
+  if (!ownerIdentitiesMatch(record1, record2)) {
+    return false;
+  }
+  if (isOwnerLive(record2)) {
+    return false;
+  }
+  try {
+    rmSync4(leaseDir, { recursive: true, force: true });
+    return true;
+  } catch (error) {
+    if (error instanceof Error) {
+      return false;
+    }
+    throw error;
+  }
+}
+async function reapOrphanIfAlive(config, simName, killMaestro) {
+  return withPoolLock(config, () => reapOrphanUnderLock(config, simName, killMaestro));
+}
+function isFullSuiteReservationReclaimable(record) {
+  return !isOwnerLive(record) && isHeartbeatStale(record);
+}
+function reservationRecordsMatch(left, right) {
+  return ownerIdentitiesMatch(left, right) && left.runId === right.runId && left.reservedAt === right.reservedAt;
+}
+
+// src/leaseReservation.ts
+async function reserveFullSuite(config, record) {
+  return withPoolLock(config, () => reserveFullSuiteUnderLock(config, record));
+}
+function reserveFullSuiteUnderLock(config, record) {
+  reclaimFullSuiteReservationUnderLock(config);
+  const reservationDir = fullSuiteReservationDir(config);
+  try {
+    mkdirSync6(poolRoot(config), { recursive: true });
+    mkdirSync6(reservationDir, { recursive: false });
+  } catch (error) {
+    const code = errnoCode4(error);
+    if (code === "EEXIST") {
+      return false;
+    }
+    throw error;
+  }
+  try {
+    atomicWriteJson(fullSuiteReservationRecordPath(config), record);
+    return true;
+  } catch (error) {
+    try {
+      rmSync5(reservationDir, { recursive: true, force: true });
+    } catch (cleanupError) {
+      if (!(cleanupError instanceof Error)) {
+        throw cleanupError;
+      }
+    }
+    throw error;
+  }
+}
+async function releaseFullSuiteReservation(config, runId, ownerPid) {
+  return withPoolLock(config, () => releaseFullSuiteReservationUnderLock(config, runId, ownerPid));
+}
+function releaseFullSuiteReservationUnderLock(config, runId, ownerPid) {
+  const record = readFullSuiteReservation(config);
+  if (record === null || record.runId !== runId || record.ownerPid !== ownerPid) {
+    return;
+  }
+  try {
+    rmSync5(fullSuiteReservationDir(config), { recursive: true, force: true });
+  } catch (error) {
+    if (!(error instanceof Error)) {
+      throw error;
+    }
+  }
+}
+function readFullSuiteReservation(config) {
+  if (!isDirPresent2(fullSuiteReservationDir(config))) {
+    return null;
+  }
+  return readJsonOrNull(fullSuiteReservationRecordPath(config));
+}
+function fullSuiteReservationLeaseAccessUnderLock(config, record) {
+  reclaimFullSuiteReservationUnderLock(config);
+  const reservation = readFullSuiteReservation(config);
+  if (reservation === null) {
+    return "open";
+  }
+  if (reservation.runId === record.runId) {
+    return "reserved";
+  }
+  return heldLeaseCountForRun(config, reservation.runId) < reservation.requestedLaneCount ? "blocked" : "open";
+}
+function heldLeaseCountForRun(config, runId) {
+  try {
+    const simsDir = join7(poolRoot(config), "sims");
+    let simNames;
+    try {
+      simNames = readdirSync2(simsDir);
+    } catch {
+      return 0;
+    }
+    let count = 0;
+    for (const simName of simNames) {
+      if (!isDirPresent2(simLeaseDir(config, simName))) {
+        continue;
+      }
+      const record = readJsonOrNull(simLeaseRecordPath(config, simName));
+      if (record === null || record.runId !== runId || !isOwnerLive(record)) {
+        continue;
+      }
+      count++;
+    }
+    return count;
+  } catch {
+    return 0;
+  }
+}
+function isDirPresent2(dirPath) {
+  try {
+    return statSync4(dirPath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function errnoCode4(error) {
+  if (typeof error !== "object" || error === null || !("code" in error)) {
+    return;
+  }
+  const { code } = error;
+  return typeof code === "string" ? code : undefined;
+}
+
+// src/lease.ts
+import { mkdirSync as mkdirSync7, rmSync as rmSync6, writeFileSync as writeFileSync5, existsSync as existsSync2 } from "fs";
+function tryLease(config, simName, record) {
+  const leaseDir = simLeaseDir(config, simName);
+  try {
+    mkdirSync7(simDir(config, simName), { recursive: true });
+  } catch (error) {
+    if (!(error instanceof Error))
+      throw error;
+  }
+  try {
+    mkdirSync7(leaseDir, { recursive: false });
+  } catch (err) {
+    const code = errnoCode5(err);
+    if (code === "EEXIST")
+      return false;
+    if (code === "ENOENT") {
+      try {
+        mkdirSync7(simDir(config, simName), { recursive: true });
+        mkdirSync7(leaseDir, { recursive: false });
+      } catch (retryErr) {
+        const retryCode = errnoCode5(retryErr);
+        if (retryCode === "EEXIST")
+          return false;
+        throw retryErr;
+      }
+    } else {
+      throw err;
+    }
+  }
+  try {
+    const recordPath = simLeaseRecordPath(config, simName);
+    atomicWriteJson(recordPath, record);
+  } catch (writeErr) {
+    try {
+      rmSync6(leaseDir, { recursive: true, force: true });
+    } catch (cleanupError) {
+      if (!(cleanupError instanceof Error))
+        throw cleanupError;
+    }
+    throw writeErr;
+  }
+  return true;
+}
+async function release(config, simName, pid) {
+  return withPoolLock(config, () => releaseUnderLock(config, simName, pid));
+}
+function releaseUnderLock(config, simName, pid) {
+  const leaseDir = simLeaseDir(config, simName);
+  const recordPath = simLeaseRecordPath(config, simName);
+  const record = readJsonOrNull(recordPath);
+  if (record === null) {
+    return;
+  }
+  if (record.ownerPid !== pid) {
+    return;
+  }
+  touchLastUsed(config, simName);
+  try {
+    rmSync6(leaseDir, { recursive: true, force: true });
+  } catch (error) {
+    if (!(error instanceof Error))
+      throw error;
+  }
+}
+function refreshHeartbeat(config, simName, pid) {
+  const leaseDir = simLeaseDir(config, simName);
+  const recordPath = simLeaseRecordPath(config, simName);
+  return withPoolLock(config, () => {
+    try {
+      if (!existsSync2(leaseDir)) {
+        return false;
+      }
+      const record = readJsonOrNull(recordPath);
+      if (record === null || record.ownerPid !== pid) {
+        return false;
+      }
+      const updated = {
+        ...record,
+        heartbeatAt: new Date().toISOString()
+      };
+      atomicWriteJson(recordPath, updated);
+      return true;
+    } catch (error) {
+      if (!(error instanceof Error))
+        throw error;
+      return false;
+    }
+  });
+}
+function setLeaseMaestroPid(config, simName, pid, maestroPid) {
+  const leaseDir = simLeaseDir(config, simName);
+  const recordPath = simLeaseRecordPath(config, simName);
+  return withPoolLock(config, () => {
+    try {
+      if (!existsSync2(leaseDir)) {
+        return false;
+      }
+      const record = readJsonOrNull(recordPath);
+      if (record === null || record.ownerPid !== pid) {
+        return false;
+      }
+      const updated = {
+        ...record,
+        maestroPid
+      };
+      atomicWriteJson(recordPath, updated);
+      return true;
+    } catch (error) {
+      if (!(error instanceof Error))
+        throw error;
+      return false;
+    }
+  });
+}
+function touchLastUsed(config, simName) {
+  const lastUsedPath = simLastUsedPath(config, simName);
+  const epochSecs = Math.floor(Date.now() / 1000).toString();
+  try {
+    mkdirSync7(simDir(config, simName), { recursive: true });
+    writeFileSync5(lastUsedPath, epochSecs, { encoding: "utf8" });
+  } catch (error) {
+    if (!(error instanceof Error))
+      throw error;
+  }
+}
+function errnoCode5(error) {
+  if (typeof error !== "object" || error === null || !("code" in error))
+    return;
+  const { code } = error;
+  return typeof code === "string" ? code : undefined;
+}
+
+// src/pool/lease-selection.ts
+async function ensureSimAvailable(config, record, simctl) {
+  return withPoolLock(config, async () => {
+    const reservationAccess = fullSuiteReservationLeaseAccessUnderLock(config, record);
+    if (reservationAccess === "blocked") {
+      return "WAIT";
+    }
+    if (reservationAccess === "open" && rankWaiters(config).length > 0 && !isBestRankedFor(config, record.runId)) {
+      return "WAIT";
+    }
+    return ensureSimAvailableUnlocked(config, record, simctl);
+  });
+}
+async function ensureSimAvailableUnlocked(config, record, simctl) {
+  const devices = await simctl.listDevices();
+  const prefix = config.pool.prefix;
+  const poolDevices = devices.filter((device) => device.name.startsWith(`${prefix}-`));
+  const freeSlot = await tryLeaseAnyFreeSlotUnlocked(config, record, poolDevices);
+  if (freeSlot !== null) {
+    return freeSlot;
+  }
+  if (poolDevices.length >= config.pool.max) {
+    return "WAIT";
+  }
+  const usedIndices = new Set(poolDevices.map((device) => {
+    const match = device.name.match(new RegExp(`^${escapeRegex(prefix)}-(\\d+)$`));
+    const indexText = match?.[1];
+    return indexText === undefined ? null : Number.parseInt(indexText, 10);
+  }).filter((index) => index !== null));
+  let newIndex = 1;
+  while (usedIndices.has(newIndex)) {
+    newIndex++;
+  }
+  const { simName, udid } = await createGapSim(config, newIndex, simctl);
+  const leased = tryLease(config, simName, record);
+  if (!leased) {
+    return "WAIT";
+  }
+  return { simName, udid };
+}
+async function tryLeaseAnyFreeSlotUnlocked(config, record, poolDevices) {
+  for (const device of poolDevices) {
+    const simName = device.name;
+    if (isDirPresent3(simLeaseDir(config, simName))) {
+      continue;
+    }
+    if (tryLease(config, simName, record)) {
+      return { simName, udid: device.udid };
+    }
+  }
+  return null;
+}
+function isDirPresent3(dirPath) {
+  try {
+    const st = statSync5(dirPath);
+    return st.isDirectory();
+  } catch {
+    return false;
+  }
+}
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+// src/pool/provisioning.ts
+import { statSync as statSync6 } from "fs";
+var DEFAULT_WARM_SETTLE_MS = 4000;
+function createWarmSimCache() {
+  const warmedByUdid = new Map;
+  return {
+    hasWarmedApp(key) {
+      const warmed = warmedByUdid.get(key.udid);
+      return warmed !== undefined && warmed.appPath === key.appPath && warmed.appMtimeMs === key.appMtimeMs;
+    },
+    rememberWarmedApp(key) {
+      warmedByUdid.set(key.udid, {
+        appPath: key.appPath,
+        appMtimeMs: key.appMtimeMs
+      });
+    }
+  };
+}
+async function bootInstallWarmFull(opts) {
+  await opts.simctl.bootAndWait(opts.udid, opts.displayMode);
+  const installResult = await installOnLease(opts.config.app.appId, opts.udid, opts.appPath, opts.simctl);
+  const cacheKey = {
+    udid: opts.udid,
+    appPath: opts.appPath,
+    appMtimeMs: installResult.sourceMtimeMs
+  };
+  if (requiresWarmSim({
+    warmSimCache: opts.warmSimCache,
+    cacheKey,
+    performedInstall: installResult.performedInstall
+  })) {
+    await warmSim({
+      udid: opts.udid,
+      config: opts.config,
+      simctl: opts.simctl,
+      settleMs: opts.warmSettleMs ?? DEFAULT_WARM_SETTLE_MS
+    });
+    opts.warmSimCache?.rememberWarmedApp(cacheKey);
+  }
+  const installed = await opts.simctl.hasApp(opts.udid, opts.config.app.appId);
+  if (!installed) {
+    throw new Error(`bootInstallWarm: bundle guard failed \u2014 ${opts.config.app.appId} not installed on ${opts.simName} (${opts.udid})`);
+  }
+}
+async function installOnLease(appId, udid, appPath, simctl) {
+  const sourceMtimeMs = getAppMtime(appPath);
+  const installedMtimeMs = await simctl.installedAppMtime(udid, appId);
+  const performedInstall = sourceMtimeMs === null || installedMtimeMs === null || sourceMtimeMs !== installedMtimeMs;
+  if (performedInstall) {
+    await simctl.install(udid, appPath);
+  }
+  return { sourceMtimeMs, performedInstall };
+}
+function requiresWarmSim(opts) {
+  if (opts.performedInstall) {
+    return true;
+  }
+  return opts.warmSimCache?.hasWarmedApp(opts.cacheKey) !== true;
+}
+async function warmSim(opts) {
+  const appId = opts.config.app.appId;
+  try {
+    await opts.simctl.launch(opts.udid, appId);
+  } catch (error) {
+    if (!(error instanceof Error)) {
+      throw error;
+    }
+  }
+  await sleep(opts.settleMs);
+  try {
+    await opts.simctl.terminate(opts.udid, appId);
+  } catch (error) {
+    if (!(error instanceof Error)) {
+      throw error;
+    }
+  }
+}
+function getAppMtime(appPath) {
+  try {
+    const st = statSync6(appPath);
+    return st.mtimeMs;
+  } catch {
+    return null;
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+// src/commands/up.ts
+init_simctl();
+
+// src/app-resolve/contracts.ts
+class AppResolveError extends Error {
+  name = "AppResolveError";
+  constructor(message) {
+    super(`maestro-manager app-resolve: ${message}`);
+  }
+}
+// src/app-resolve/bundle-metadata.ts
+import { existsSync as existsSync3, statSync as statSync8 } from "fs";
+import { join as join8 } from "path";
+import { spawnSync } from "child_process";
+function readCFBundleIdentifier(appPath) {
+  const plistPath = join8(appPath, "Info.plist");
+  if (!existsSync3(plistPath)) {
+    throw new AppResolveError(`Info.plist not found in ${appPath}`);
+  }
+  const plutilResult = spawnSync("plutil", ["-extract", "CFBundleIdentifier", "raw", plistPath], {
+    encoding: "utf8"
+  });
+  if (plutilResult.status === 0 && plutilResult.stdout) {
+    const value = plutilResult.stdout.trim();
+    if (value.length > 0)
+      return value;
+  }
+  const plistBase = join8(appPath, "Info");
+  const defaultsResult = spawnSync("defaults", ["read", plistBase, "CFBundleIdentifier"], {
+    encoding: "utf8"
+  });
+  if (defaultsResult.status === 0 && defaultsResult.stdout) {
+    const value = defaultsResult.stdout.trim();
+    if (value.length > 0)
+      return value;
+  }
+  throw new AppResolveError(`Could not read CFBundleIdentifier from ${plistPath}.
+` + `Tried: plutil -extract, defaults read.`);
+}
+function bundleMtime(appPath) {
+  try {
+    return statSync8(appPath).mtimeMs;
+  } catch (error) {
+    if (!(error instanceof Error))
+      throw error;
+    return 0;
+  }
+}
+// src/app-resolve/flow-app-id.ts
+import { readFileSync as readFileSync3 } from "fs";
+function readAppIdFromFlow(flowPath) {
+  let text;
+  try {
+    text = readFileSync3(flowPath, { encoding: "utf8" });
+  } catch (error) {
+    if (!(error instanceof Error))
+      throw error;
+    return null;
+  }
+  for (const line of text.split(`
+`)) {
+    const match = line.match(/^appId:\s*(.+)$/);
+    const rawValue = match?.[1];
+    if (rawValue === undefined)
+      continue;
+    const value = rawValue.trim();
+    const withoutComment = value.replace(/\s*#.*$/, "").trim();
+    if (withoutComment.length > 0)
+      return withoutComment;
+  }
+  return null;
+}
+// src/app-resolve/resolve-app.ts
+import { existsSync as existsSync6 } from "fs";
+
+// src/app-resolve/candidate-search.ts
+import { existsSync as existsSync4, readdirSync as readdirSync3, statSync as statSync9 } from "fs";
+import { join as join10 } from "path";
+
+// src/app-resolve/search-dirs.ts
+import { homedir as homedir3 } from "os";
+import { join as join9 } from "path";
+var DEFAULT_DERIVED_DATA = join9(homedir3(), "Library", "Developer", "Xcode", "DerivedData");
+function buildSearchDirs(searchDirs) {
+  const dirs = new Set([DEFAULT_DERIVED_DATA]);
+  for (const dir of searchDirs) {
+    const expanded = dir.startsWith("~/") ? join9(homedir3(), dir.slice(2)) : dir;
+    dirs.add(expanded);
+  }
+  return [...dirs];
+}
+
+// src/app-resolve/candidate-search.ts
+async function scanForApp(appId, searchDirs) {
+  const dirsToScan = buildSearchDirs(searchDirs);
+  const results = [];
+  for (const baseDir of dirsToScan) {
+    if (!existsSync4(baseDir))
+      continue;
+    const candidates = findAppBundles(baseDir, 4);
+    for (const appPath of candidates) {
+      try {
+        const bundleId = readCFBundleIdentifier(appPath);
+        if (bundleId === appId) {
+          const mtimeMs = bundleMtime(appPath);
+          results.push({ appPath, appId: bundleId, mtimeMs });
+        }
+      } catch (error) {
+        if (!(error instanceof Error))
+          throw error;
+      }
+    }
+  }
+  return results;
+}
+function findAppBundles(dir, maxDepth) {
+  if (maxDepth < 0)
+    return [];
+  const results = [];
+  let entries;
+  try {
+    entries = readdirSync3(dir);
+  } catch (error) {
+    if (!(error instanceof Error))
+      throw error;
+    return [];
+  }
+  for (const entry of entries) {
+    if (entry.startsWith("."))
+      continue;
+    const fullPath = join10(dir, entry);
+    if (entry.endsWith(".app")) {
+      try {
+        const st = statSync9(fullPath);
+        if (st.isDirectory()) {
+          results.push(fullPath);
+        }
+      } catch (error) {
+        if (!(error instanceof Error))
+          throw error;
+      }
+    } else if (maxDepth > 0) {
+      try {
+        const st = statSync9(fullPath);
+        if (st.isDirectory()) {
+          results.push(...findAppBundles(fullPath, maxDepth - 1));
+        }
+      } catch (error) {
+        if (!(error instanceof Error))
+          throw error;
+      }
+    }
+  }
+  return results;
+}
+function rankNewestApp(candidates) {
+  const ranked = [...candidates].sort((a, b) => b.mtimeMs - a.mtimeMs);
+  return ranked[0] ?? null;
+}
+
+// src/app-resolve/glob-expansion.ts
+import { existsSync as existsSync5, readdirSync as readdirSync4 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join11 } from "path";
+function expandGlob(pattern) {
+  const expanded = pattern.startsWith("~/") ? join11(homedir4(), pattern.slice(2)) : pattern;
+  if (!containsSegmentGlob(expanded)) {
+    return existsSync5(expanded) ? [expanded] : [];
+  }
+  if (!expanded.includes("/")) {
+    return [];
+  }
+  let matches = expanded.startsWith("/") ? ["/"] : ["."];
+  const segments = expanded.split("/").filter((segment) => segment.length > 0);
+  for (const segment of segments) {
+    matches = expandGlobSegment(matches, segment);
+    if (matches.length === 0)
+      return [];
+  }
+  return matches.filter((match) => existsSync5(match));
+}
+function expandGlobSegment(basePaths, segment) {
+  const results = [];
+  if (containsSegmentGlob(segment)) {
+    const regex = segmentGlobToRegExp(segment);
+    for (const basePath of basePaths) {
+      let entries;
+      try {
+        entries = readdirSync4(basePath);
+      } catch (error) {
+        if (!(error instanceof Error))
+          throw error;
+        continue;
+      }
+      for (const entry of entries) {
+        if (regex.test(entry)) {
+          const candidate = join11(basePath, entry);
+          if (existsSync5(candidate))
+            results.push(candidate);
+        }
+      }
+    }
+    return results;
+  }
+  for (const basePath of basePaths) {
+    const candidate = join11(basePath, segment);
+    if (existsSync5(candidate))
+      results.push(candidate);
+  }
+  return results;
+}
+function containsSegmentGlob(value) {
+  return value.includes("*") || value.includes("?");
+}
+function segmentGlobToRegExp(segment) {
+  let source = "^";
+  for (const char of segment) {
+    if (char === "*") {
+      source += "[^/]*";
+    } else if (char === "?") {
+      source += "[^/]";
+    } else {
+      source += escapeRegExp(char);
+    }
+  }
+  source += "$";
+  return new RegExp(source);
+}
+function escapeRegExp(value) {
+  return value.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
+}
+
+// src/app-resolve/resolve-app.ts
+async function resolveApp(opts) {
+  const { explicitApp, config, flow } = opts;
+  if (explicitApp !== undefined) {
+    return resolveExplicit(explicitApp);
+  }
+  if (config.path !== undefined && config.path !== "") {
+    return resolveStaticPath(config.path);
+  }
+  if (config.glob !== undefined && config.glob !== "") {
+    return resolveGlob(config.glob);
+  }
+  const appId = resolveTargetAppId({ config, flow });
+  const candidate = rankNewestApp(await scanForApp(appId, config.searchDirs));
+  if (candidate !== null) {
+    return candidate;
+  }
+  const searched = buildSearchDirs(config.searchDirs);
+  throw new AppResolveError(`No .app bundle found for appId "${appId}" in: ${searched.join(", ")}.
+` + `Fix one of:
+` + `  \u2022 Pass --app <path/to/Your.app> on the CLI.
+` + `  \u2022 Set "app.path" or "app.glob" in maestro-manager.config.json.
+` + `  \u2022 Build the app so it lands under ~/Library/Developer/Xcode/DerivedData or a configured searchDir.`);
+}
+function resolveExplicit(appPath) {
+  if (!appPath.endsWith(".app")) {
+    throw new AppResolveError(`--app path must end in ".app" (got: ${appPath})`);
+  }
+  if (!existsSync6(appPath)) {
+    throw new AppResolveError(`--app path does not exist: ${appPath}`);
+  }
+  const appId = readCFBundleIdentifier(appPath);
+  const mtimeMs = bundleMtime(appPath);
+  return { appPath, appId, mtimeMs };
+}
+function resolveStaticPath(appPath) {
+  if (!existsSync6(appPath)) {
+    throw new AppResolveError(`config.app.path does not exist: ${appPath}.
+` + `Fix: update "app.path" in maestro-manager.config.json or build the app first.`);
+  }
+  if (!appPath.endsWith(".app")) {
+    throw new AppResolveError(`config.app.path must end in ".app" (got: ${appPath})`);
+  }
+  const appId = readCFBundleIdentifier(appPath);
+  const mtimeMs = bundleMtime(appPath);
+  return { appPath, appId, mtimeMs };
+}
+function resolveGlob(pattern) {
+  const matches = expandGlob(pattern);
+  if (matches.length === 0) {
+    throw new AppResolveError(`config.app.glob "${pattern}" matched no .app bundles.
+` + `Fix: update "app.glob" in maestro-manager.config.json or build the app first.`);
+  }
+  const candidates = [];
+  for (const appPath of matches) {
+    if (!appPath.endsWith(".app") || !existsSync6(appPath))
+      continue;
+    try {
+      const appId = readCFBundleIdentifier(appPath);
+      candidates.push({ appPath, appId, mtimeMs: bundleMtime(appPath) });
+    } catch (error) {
+      if (error instanceof AppResolveError)
+        continue;
+      throw error;
+    }
+  }
+  const ranked = rankNewestApp(candidates);
+  if (ranked === null) {
+    throw new AppResolveError(`config.app.glob "${pattern}" matched paths but no valid app bundle was found.`);
+  }
+  return ranked;
+}
+function resolveTargetAppId(opts) {
+  const { config, flow } = opts;
+  if (flow !== undefined && flow !== "") {
+    const fromFlow = readAppIdFromFlow(flow);
+    if (fromFlow !== null)
+      return fromFlow;
+  }
+  if (config.appId !== "") {
+    return config.appId;
+  }
+  throw new AppResolveError(`Cannot determine appId: no flow given, and "app.appId" is empty in maestro-manager.config.json.
+` + `Fix: set "app.appId" in the config, or pass --app <path/to/Your.app>.`);
+}
+// src/commands/up.ts
+async function runUp(opts) {
+  const { config } = opts;
+  const simctlImpl = opts.simctlImpl ?? exports_simctl;
+  const displayMode = opts.displayMode ?? DEFAULT_SIMULATOR_DISPLAY_MODE;
+  mkdirSync8(poolRoot(config), { recursive: true });
+  atomicWriteJson(configSnapshotPath(config), config);
+  const poolState = await reconcile(config, simctlImpl);
+  const existingNames = new Set(poolState.slots.map((s) => s.simName));
+  const prefix = config.pool.prefix;
+  const target = config.pool.default;
+  const usedIndices = new Set;
+  for (const name of existingNames) {
+    const m = name.match(new RegExp(`^${escapeRegex2(prefix)}-(\\d+)$`));
+    const indexText = m?.[1];
+    if (indexText !== undefined)
+      usedIndices.add(Number.parseInt(indexText, 10));
+  }
+  const simsToWarm = [];
+  for (const slot of poolState.slots) {
+    simsToWarm.push({ simName: slot.simName, udid: slot.udid });
+  }
+  for (let i = 1;simsToWarm.length < target; i++) {
+    if (!usedIndices.has(i)) {
+      const created = await createGapSim(config, i, simctlImpl);
+      simsToWarm.push(created);
+      usedIndices.add(i);
+    }
+  }
+  let resolvedAppPath;
+  if (opts.appPath !== undefined) {
+    const resolved = await resolveApp({ explicitApp: opts.appPath, config: config.app });
+    resolvedAppPath = resolved.appPath;
+  } else {
+    try {
+      const resolved = await resolveApp({ config: config.app });
+      resolvedAppPath = resolved.appPath;
+    } catch {
+      resolvedAppPath = "";
+    }
+  }
+  await Promise.all(simsToWarm.map(async ({ simName, udid }) => {
+    process.stderr.write(`[maestro-manager] up: booting ${simName} (${udid})...
+`);
+    if (resolvedAppPath !== "") {
+      await bootInstallWarmFull({
+        config,
+        simName,
+        udid,
+        appPath: resolvedAppPath,
+        simctl: simctlImpl,
+        displayMode
+      });
+    } else {
+      await simctlImpl.bootAndWait(udid, displayMode);
+    }
+    process.stderr.write(`[maestro-manager] up: ${simName} ready.
+`);
+  }));
+  process.stderr.write(`[maestro-manager] up: ${simsToWarm.length} sim(s) ready.
+`);
+}
+function escapeRegex2(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/commands/test.ts
+import { basename as basename5 } from "path";
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/maestro/argv.ts
+function buildMaestroInvocation(opts) {
+  return {
+    command: "maestro",
+    args: ["--device", opts.udid, "test", opts.flow, ...opts.passthrough]
+  };
+}
+// src/maestro/java-home.ts
+import { execFileSync as execFileSync5 } from "child_process";
+import { statSync as statSync10 } from "fs";
+import { homedir as homedir5 } from "os";
+function resolveJavaHome(config) {
+  const javaConfig = config.java;
+  if (javaConfig.home !== null && javaConfig.home.length > 0) {
+    const expanded = expandTilde2(javaConfig.home);
+    if (isDirectory(expanded))
+      return expanded;
+  }
+  for (const entry of javaConfig.autodetect) {
+    const resolved = resolveAutodetectEntry(entry);
+    if (resolved !== null)
+      return resolved;
+  }
+  return null;
+}
+function expandTilde2(path) {
+  if (path === "~" || path.startsWith("~/")) {
+    return homedir5() + path.slice(1);
+  }
+  return path;
+}
+function isDirectory(path) {
+  try {
+    return statSync10(path).isDirectory();
+  } catch (error) {
+    if (error instanceof Error)
+      return false;
+    throw error;
+  }
+}
+function resolveAutodetectEntry(entry) {
+  switch (entry) {
+    case "JAVA_HOME": {
+      const javaHome = process.env["JAVA_HOME"];
+      return javaHome !== undefined && isDirectory(javaHome) ? javaHome : null;
+    }
+    case "mise": {
+      const temurinLatest = expandTilde2("~/.local/share/mise/installs/java/temurin-latest");
+      if (isDirectory(temurinLatest))
+        return temurinLatest;
+      return commandDirectory("mise", ["where", "java"]);
+    }
+    case "/usr/libexec/java_home":
+      return commandDirectory("/usr/libexec/java_home", []);
+    default: {
+      const expanded = expandTilde2(entry);
+      return isDirectory(expanded) ? expanded : null;
+    }
+  }
+}
+function commandDirectory(command, args) {
+  try {
+    const path = execFileSync5(command, [...args], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: 5000
+    }).trim();
+    return path.length > 0 && isDirectory(path) ? path : null;
+  } catch (error) {
+    if (error instanceof Error)
+      return null;
+    throw error;
+  }
+}
+// src/maestroFailure.ts
+function detectFailureLine(logContent) {
+  const failurePattern = /Assertion is false|Element .* not|FAILED/i;
+  for (const line of logContent.split(`
+`)) {
+    if (failurePattern.test(line)) {
+      return line.slice(0, 90);
+    }
+  }
+  return null;
+}
+// src/maestroRunFlow.ts
+import { spawn as nodeSpawn } from "child_process";
+import { appendFileSync, createWriteStream, mkdirSync as mkdirSync9, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname3 } from "path";
+var FLOW_TIMEOUT_MS = 460000;
+var TIMEOUT_EXIT_CODE = 124;
+var TIMEOUT_LOG_MESSAGE = `
+[maestro-manager] Flow timed out after 460s (exit code 124)
+`;
+var defaultRunFlowAdapters = {
+  spawn: (command, args, options) => nodeSpawn(command, [...args], options),
+  setTimeout: (callback, ms) => setTimeout(callback, ms),
+  clearTimeout: (handle) => clearTimeout(handle),
+  kill: (pid, signal) => {
+    process.kill(pid, signal);
+  }
+};
+async function runFlow(opts) {
+  const {
+    udid,
+    flow,
+    passthrough,
+    env: extraEnv,
+    javaHome,
+    logPath,
+    detached = false,
+    onSpawned,
+    adapters = defaultRunFlowAdapters
+  } = opts;
+  const childEnv = { ...process.env };
+  if (javaHome) {
+    childEnv["JAVA_HOME"] = javaHome;
+  }
+  if (extraEnv) {
+    for (const [k, v] of Object.entries(extraEnv)) {
+      childEnv[k] = v;
+    }
+  }
+  mkdirSync9(dirname3(logPath), { recursive: true });
+  const invocation = buildMaestroInvocation({ udid, flow, passthrough });
+  const logLines = [];
+  let exitCode = 1;
+  let spawnedChildPid = 0;
+  try {
+    const proc = adapters.spawn(invocation.command, invocation.args, {
+      env: childEnv,
+      stdio: ["ignore", "pipe", "pipe"],
+      detached
+    });
+    const procPid = proc.pid;
+    spawnedChildPid = procPid ?? 0;
+    const logStream = createWriteStream(logPath, { encoding: "utf8" });
+    let acceptingLogWrites = true;
+    const writeLog = (text) => {
+      if (!acceptingLogWrites) {
+        return;
+      }
+      logLines.push(text);
+      logStream.write(text);
+    };
+    proc.stdout?.on("data", (chunk) => writeLog(chunkToUtf8(chunk)));
+    proc.stderr?.on("data", (chunk) => writeLog(chunkToUtf8(chunk)));
+    const waiter = createFlowProcessWaiter({
+      proc,
+      procPid,
+      detached,
+      adapters,
+      writeLog
+    });
+    try {
+      if (onSpawned) {
+        await onSpawned(spawnedChildPid);
+      }
+      exitCode = await waiter.done;
+    } catch (error) {
+      waiter.clearTimeout();
+      killFlowProcess(procPid, detached, adapters);
+      await waiter.done;
+      throw error;
+    } finally {
+      acceptingLogWrites = false;
+      await new Promise((resolve3) => {
+        logStream.end(() => resolve3());
+      });
+    }
+  } catch (error) {
+    if (!(error instanceof Error))
+      throw error;
+    const errorMsg = `
+[maestro-manager] Spawn error: ${error.message}
+`;
+    logLines.push(errorMsg);
+    appendOrWriteLog(logPath, errorMsg);
+    exitCode = 1;
+  }
+  const logContent = logLines.join("");
+  const failureLine = detectFailureLine(logContent);
+  const passed = exitCode === 0 && failureLine === null;
+  return { passed, logPath, childPid: spawnedChildPid };
+}
+function createFlowProcessWaiter(opts) {
+  let state = "running";
+  let timerHandle = null;
+  let exitCodeFromExit = null;
+  const clearFlowTimeout = () => {
+    if (timerHandle === null) {
+      return;
+    }
+    opts.adapters.clearTimeout(timerHandle);
+    timerHandle = null;
+  };
+  const done = new Promise((resolve3) => {
+    const resolveOnce = (exitCode) => {
+      if (state === "resolved") {
+        return;
+      }
+      state = "resolved";
+      clearFlowTimeout();
+      resolve3(exitCode);
+    };
+    opts.proc.once("exit", (code) => {
+      if (state !== "running") {
+        return;
+      }
+      state = "exited";
+      exitCodeFromExit = normalizeExitCode(code);
+      clearFlowTimeout();
+    });
+    opts.proc.once("close", (code) => {
+      if (state === "timed_out") {
+        resolveOnce(TIMEOUT_EXIT_CODE);
+        return;
+      }
+      resolveOnce(exitCodeFromExit ?? normalizeExitCode(code));
+    });
+    opts.proc.once("error", (error) => {
+      if (state === "timed_out") {
+        resolveOnce(TIMEOUT_EXIT_CODE);
+        return;
+      }
+      opts.writeLog(`
+[maestro-manager] Spawn error: ${error.message}
+`);
+      resolveOnce(1);
+    });
+    timerHandle = opts.adapters.setTimeout(() => {
+      if (state !== "running") {
+        return;
+      }
+      state = "timed_out";
+      clearFlowTimeout();
+      opts.writeLog(TIMEOUT_LOG_MESSAGE);
+      killFlowProcess(opts.procPid, opts.detached, opts.adapters);
+    }, FLOW_TIMEOUT_MS);
+  });
+  return { done, clearTimeout: clearFlowTimeout };
+}
+function killFlowProcess(procPid, detached, adapters) {
+  if (procPid === undefined) {
+    return;
+  }
+  const killPid = detached ? -procPid : procPid;
+  try {
+    adapters.kill(killPid, "SIGKILL");
+  } catch (error) {
+    if (error instanceof Error) {
+      return;
+    }
+    throw error;
+  }
+}
+function normalizeExitCode(code) {
+  return code ?? 1;
+}
+function chunkToUtf8(chunk) {
+  if (typeof chunk === "string") {
+    return chunk;
+  }
+  return Buffer.from(chunk).toString("utf8");
+}
+function appendOrWriteLog(logPath, text) {
+  mkdirSync9(dirname3(logPath), { recursive: true });
+  try {
+    appendFileSync(logPath, text, { encoding: "utf8" });
+  } catch (error) {
+    if (error instanceof Error) {
+      writeFileSync6(logPath, text, { encoding: "utf8" });
+      return;
+    }
+    throw error;
+  }
+}
+// src/runFlowExecutor.ts
+import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync8 } from "fs";
+import { basename as basename2, dirname as dirname4 } from "path";
+import { performance } from "perf_hooks";
+
+// src/runLeaseAcquire.ts
+import { basename } from "path";
+var DEFAULT_FLOW_WAIT_DEADLINE_MS = 25 * 60 * 1000;
+var DEFAULT_POLL_INTERVAL_MS = 500;
+
+class FlowWaitTimeoutError extends Error {
+  name = "FlowWaitTimeoutError";
+  constructor(flow, runId, deadlineMs) {
+    super(`[maestro-manager] runWorker: flow "${basename(flow)}" waited > ${deadlineMs / 60000} min for a sim \u2014 starvation bound exceeded (runId=${runId})`);
+  }
+}
+async function acquireLease(context, assignment) {
+  const waitStart = Date.now();
+  const deadlineMs = context.opts.flowWaitDeadlineMs ?? DEFAULT_FLOW_WAIT_DEADLINE_MS;
+  const pollIntervalMs = context.opts.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+  writeTicket(context.opts.config, context.opts.runId, waiterTicket(context));
+  return acquireLeaseAttempt({ context, assignment, waitStart, deadlineMs, pollIntervalMs });
+}
+async function acquireLeaseAttempt(opts) {
+  if (Date.now() - opts.waitStart > opts.deadlineMs) {
+    throw new FlowWaitTimeoutError(opts.assignment.flow, opts.context.opts.runId, opts.deadlineMs);
+  }
+  const leaseRecord = {
+    ownerPid: opts.context.pid,
+    ownerStart: opts.context.ownerStart,
+    bootId: opts.context.bootId,
+    worktree: opts.context.opts.agent,
+    runId: opts.context.opts.runId,
+    flow: basename(opts.assignment.flow),
+    app: opts.context.opts.appResolved.appPath,
+    leasedAt: new Date().toISOString(),
+    heartbeatAt: new Date().toISOString(),
+    maestroPid: 0
+  };
+  const leaseResult = await ensureSimAvailable(opts.context.opts.config, leaseRecord, opts.context.opts.simctl);
+  if (leaseResult !== "WAIT") {
+    return leaseResult;
+  }
+  await sleep2(opts.pollIntervalMs);
+  return acquireLeaseAttempt(opts);
+}
+function waiterTicket(context) {
+  return {
+    agent: context.opts.agent,
+    ownerPid: context.pid,
+    ownerStart: context.ownerStart,
+    bootId: context.bootId,
+    enqueuedAt: new Date().toISOString(),
+    wantCount: Math.max(1, context.opts.flows.length - context.completedCount)
+  };
+}
+function sleep2(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+
+// src/runTraps.ts
+import { mkdirSync as mkdirSync10, rmSync as rmSync7, writeFileSync as writeFileSync7 } from "fs";
+var ownedLeases = new Map;
+var inFlightMaestroPids = new Map;
+var trapsInstalled = false;
+function installTraps() {
+  if (trapsInstalled) {
+    return;
+  }
+  trapsInstalled = true;
+  process.on("exit", releaseOwnLeases);
+  process.on("SIGINT", () => {
+    releaseOwnLeases();
+    process.exit(130);
+  });
+  process.on("SIGTERM", () => {
+    releaseOwnLeases();
+    process.exit(143);
+  });
+}
+function trackOwnedLease(simName, config) {
+  ownedLeases.set(simName, config);
+}
+function clearOwnedLease(simName) {
+  ownedLeases.delete(simName);
+}
+function trackMaestroPid(simName, childPid) {
+  inFlightMaestroPids.set(simName, childPid);
+}
+function clearMaestroPid(simName) {
+  inFlightMaestroPids.delete(simName);
+}
+function killMaestroGroup(childPid) {
+  if (childPid <= 0) {
+    return;
+  }
+  try {
+    process.kill(-childPid, "SIGKILL");
+  } catch (error) {
+    if (error instanceof Error) {
+      return;
+    }
+    throw error;
+  }
+}
+function releaseOwnLeases() {
+  for (const childPid of inFlightMaestroPids.values()) {
+    killMaestroGroup(childPid);
+  }
+  for (const [simName, config] of ownedLeases) {
+    tryBestEffort(() => {
+      touchLastUsed2(config, simName);
+      rmSync7(simLeaseDir(config, simName), { recursive: true, force: true });
+    });
+  }
+}
+function touchLastUsed2(config, simName) {
+  tryBestEffort(() => {
+    mkdirSync10(simDir(config, simName), { recursive: true });
+    writeFileSync7(simLastUsedPath(config, simName), Math.floor(Date.now() / 1000).toString(), "utf8");
+  });
+}
+function tryBestEffort(action) {
+  try {
+    action();
+  } catch (error) {
+    if (error instanceof Error) {
+      return;
+    }
+  }
+}
+
+// src/runFlowExecutor.ts
+var HEARTBEAT_INTERVAL_MS = 30000;
+var NO_SIM_ASSIGNED = "<none>";
+
+class MaestroPidHandoffError extends Error {
+  name = "MaestroPidHandoffError";
+  constructor(simName, childPid) {
+    super(`[maestro-manager] failed to persist Maestro pid ${childPid} before running flow on ${simName}`);
+  }
+}
+var defaultSimPreparer = async (opts) => {
+  await bootInstallWarmFull({
+    config: opts.config,
+    simName: opts.simName,
+    udid: opts.udid,
+    appPath: opts.appPath,
+    simctl: opts.simctl,
+    displayMode: opts.displayMode,
+    warmSimCache: opts.warmSimCache
+  });
+};
+async function runFlowAssignment(context, assignment) {
+  const logPath = runFlowLogPath(context.opts.config, context.opts.runId, basename2(assignment.flow));
+  try {
+    const lease = await acquireLease(context, assignment);
+    return await runFlowOnLease(context, assignment, lease, logPath);
+  } catch (error) {
+    if (!(error instanceof Error)) {
+      throw error;
+    }
+    writeFlowErrorLog(logPath, error);
+    return { flow: basename2(assignment.flow), result: "FAIL", sim: NO_SIM_ASSIGNED, durationMs: 0 };
+  }
+}
+async function runFlowOnLease(context, assignment, lease, logPath) {
+  let spawnedChildPid = 0;
+  let flowStartedAtMs = null;
+  let stopHeartbeat;
+  trackOwnedLease(lease.simName, context.opts.config);
+  try {
+    await context.simPreparer({
+      config: context.opts.config,
+      simName: lease.simName,
+      udid: lease.udid,
+      appPath: context.opts.appResolved.appPath,
+      simctl: context.opts.simctl,
+      displayMode: context.opts.displayMode,
+      warmSimCache: context.warmSimCache
+    });
+    stopHeartbeat = startHeartbeat(context, lease.simName);
+    flowStartedAtMs = performance.now();
+    const flowResult = await context.flowRunner({
+      udid: lease.udid,
+      flow: assignment.flow,
+      passthrough: [...context.opts.passthrough],
+      ...context.opts.env !== undefined ? { env: context.opts.env } : {},
+      javaHome: context.javaHome,
+      logPath,
+      detached: true,
+      onSpawned: async (childPid) => {
+        spawnedChildPid = childPid;
+        trackMaestroPid(lease.simName, childPid);
+        if (childPid > 0) {
+          const handoffPersisted = await setLeaseMaestroPid(context.opts.config, lease.simName, context.pid, childPid);
+          if (!handoffPersisted) {
+            throw new MaestroPidHandoffError(lease.simName, childPid);
+          }
+        }
+      }
+    });
+    return {
+      flow: basename2(assignment.flow),
+      result: flowResult.passed ? "PASS" : "FAIL",
+      sim: lease.simName,
+      durationMs: durationMsSince(flowStartedAtMs)
+    };
+  } catch (error) {
+    if (!(error instanceof Error)) {
+      throw error;
+    }
+    if (spawnedChildPid > 0) {
+      killMaestroGroup(spawnedChildPid);
+    }
+    writeFlowErrorLog(logPath, error);
+    return {
+      flow: basename2(assignment.flow),
+      result: "FAIL",
+      sim: lease.simName,
+      durationMs: flowStartedAtMs === null ? 0 : durationMsSince(flowStartedAtMs)
+    };
+  } finally {
+    stopHeartbeat?.();
+    clearOwnedLease(lease.simName);
+    clearMaestroPid(lease.simName);
+    if (spawnedChildPid > 0) {
+      await setLeaseMaestroPid(context.opts.config, lease.simName, context.pid, 0);
+    }
+    await release(context.opts.config, lease.simName, context.pid);
+  }
+}
+function durationMsSince(startedAtMs) {
+  return Math.max(0, Math.round(performance.now() - startedAtMs));
+}
+function startHeartbeat(context, simName) {
+  const heartbeatHandle = setInterval(() => {
+    refreshHeartbeat(context.opts.config, simName, context.pid).catch(ignoreHeartbeatError);
+  }, HEARTBEAT_INTERVAL_MS);
+  return () => clearInterval(heartbeatHandle);
+}
+function writeFlowErrorLog(logPath, error) {
+  try {
+    mkdirSync11(dirname4(logPath), { recursive: true });
+    writeFileSync8(logPath, `
+[maestro-manager] Flow failed: ${errorMessage(error)}
+`, {
+      encoding: "utf8"
+    });
+  } catch (writeError) {
+    if (writeError instanceof Error) {
+      return;
+    }
+    throw writeError;
+  }
+}
+function ignoreHeartbeatError(error) {
+  if (error instanceof Error) {
+    return;
+  }
+  throw error;
+}
+function errorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+
+// src/runFlowOrdering.ts
+import { basename as basename3 } from "path";
+function scheduleFlowsByDurationHistory(flows, history) {
+  const durationByFlowName = latestDurationByFlowName(history);
+  const candidates = flows.map((flow, index) => ({
+    assignment: { index, flow },
+    inputIndex: index,
+    durationMs: durationByFlowName.get(basename3(flow)) ?? null
+  }));
+  const known = candidates.filter(isKnownFlowScheduleCandidate).sort(compareKnownFlows);
+  const unknown = candidates.filter((candidate) => !isKnownFlowScheduleCandidate(candidate));
+  return [...known, ...unknown].map((candidate) => candidate.assignment);
+}
+function readPriorRunDurationHistory(config, currentRunId) {
+  const index = readJsonOrNull(runsIndexPath(config)) ?? [];
+  const history = [];
+  for (const entry of index.slice().reverse()) {
+    if (entry.runId === currentRunId || !isCompletedRunState(entry.state)) {
+      continue;
+    }
+    const record = readJsonOrNull(runRecordPath(config, entry.runId));
+    if (record !== null && isCompletedRunState(record.state)) {
+      history.push(record);
+    }
+  }
+  return history;
+}
+function latestDurationByFlowName(history) {
+  const durationByFlowName = new Map;
+  for (const record of history) {
+    for (const result of record.summary) {
+      const flowName = basename3(result.flow);
+      if (durationByFlowName.has(flowName) || !isEligibleDuration(result.durationMs)) {
+        continue;
+      }
+      durationByFlowName.set(flowName, result.durationMs);
+    }
+  }
+  return durationByFlowName;
+}
+function isKnownFlowScheduleCandidate(candidate) {
+  return candidate.durationMs !== null;
+}
+function compareKnownFlows(left, right) {
+  const durationOrder = right.durationMs - left.durationMs;
+  if (durationOrder !== 0) {
+    return durationOrder;
+  }
+  return left.inputIndex - right.inputIndex;
+}
+function isEligibleDuration(durationMs) {
+  return durationMs !== undefined && Number.isFinite(durationMs) && durationMs >= 0;
+}
+function isCompletedRunState(state) {
+  return state === "passed" || state === "failed";
+}
+
+// src/runFlowScheduler.ts
+class IncompleteRunResultsError extends Error {
+  name = "IncompleteRunResultsError";
+  constructor(runId) {
+    super(`[maestro-manager] runWorker: run ${runId} ended before every flow reported a result`);
+  }
+}
+
+class WorkerExecutionError extends Error {
+  name = "WorkerExecutionError";
+  constructor(reason) {
+    super(`[maestro-manager] runWorker: worker failed: ${errorMessage2(reason)}`);
+  }
+}
+async function runFlowsConcurrently(opts) {
+  if (opts.flows.length === 0) {
+    return [];
+  }
+  const context = createSchedulerContext(opts);
+  const workerCount = Math.min(effectiveConcurrency(opts.config), opts.flows.length);
+  const workers = Array.from({ length: workerCount }, () => runFlowWorker(context));
+  const settled = await Promise.allSettled(workers);
+  const rejected = settled.find((result) => result.status === "rejected");
+  if (rejected !== undefined) {
+    throw new WorkerExecutionError(rejected.reason);
+  }
+  return finalResults(context);
+}
+function createSchedulerContext(opts) {
+  const pid = process.pid;
+  const scheduledAssignments = scheduleFlowsByDurationHistory(opts.flows, readPriorRunDurationHistory(opts.config, opts.runId));
+  return {
+    opts,
+    pid,
+    ownerStart: processStartTime(pid) ?? "",
+    bootId: machineBootId(),
+    javaHome: resolveJavaHome(opts.config),
+    flowRunner: opts.flowRunner ?? runFlow,
+    simPreparer: opts.simPreparer ?? defaultSimPreparer,
+    warmSimCache: createWarmSimCache(),
+    scheduledAssignments,
+    resultsByIndex: Array.from({ length: opts.flows.length }),
+    nextAssignmentIndex: 0,
+    completedCount: 0
+  };
+}
+async function runFlowWorker(context) {
+  const assignment = takeNextAssignment(context);
+  if (assignment === null) {
+    return;
+  }
+  const result = await runFlowAssignment(context, assignment);
+  recordResult(context, assignment.index, result);
+  return runFlowWorker(context);
+}
+function takeNextAssignment(context) {
+  const assignment = context.scheduledAssignments[context.nextAssignmentIndex];
+  if (assignment === undefined) {
+    return null;
+  }
+  context.nextAssignmentIndex += 1;
+  return assignment;
+}
+function recordResult(context, index, result) {
+  context.resultsByIndex[index] = result;
+  context.completedCount += 1;
+  context.opts.onResultsChanged(completedResults(context));
+}
+function completedResults(context) {
+  return context.resultsByIndex.filter((result) => result !== undefined);
+}
+function finalResults(context) {
+  const results = completedResults(context);
+  if (results.length !== context.opts.flows.length) {
+    throw new IncompleteRunResultsError(context.opts.runId);
+  }
+  return results;
+}
+function effectiveConcurrency(config) {
+  return Math.max(1, Math.min(config.pool.default, config.pool.max));
+}
+function errorMessage2(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+
+// src/runRecord.ts
+import { mkdirSync as mkdirSync12 } from "fs";
+function initRunRecord(opts) {
+  const record = {
+    owner: opts.agent,
+    submittedAt: new Date().toISOString(),
+    app: opts.appPath,
+    flows: [...opts.flows],
+    state: "queued",
+    summary: []
+  };
+  mkdirSync12(runDir(opts.config, opts.runId), { recursive: true });
+  atomicWriteJson(runRecordPath(opts.config, opts.runId), record);
+  updateRunsIndex(opts.config, opts.runId, "queued");
+  return record;
+}
+function updateRunRecord(config, runId, updates) {
+  const existing = readJsonOrNull(runRecordPath(config, runId));
+  if (existing === null) {
+    return;
+  }
+  const updated = {
+    ...existing,
+    ...updates
+  };
+  atomicWriteJson(runRecordPath(config, runId), updated);
+  if (updates.state !== undefined) {
+    updateRunsIndex(config, runId, updates.state);
+  }
+}
+function updateRunsIndex(config, runId, state) {
+  try {
+    const indexPath = runsIndexPath(config);
+    const existing = readJsonOrNull(indexPath) ?? [];
+    const filtered = existing.filter((entry) => entry.runId !== runId);
+    filtered.push({ runId, state, updatedAt: new Date().toISOString() });
+    atomicWriteJson(indexPath, filtered.slice(-200));
+  } catch (error) {
+    if (error instanceof Error) {
+      return;
+    }
+    throw error;
+  }
+}
+
+// src/run.ts
+async function runWorker(opts) {
+  const {
+    runId,
+    agent,
+    flows,
+    appResolved,
+    config,
+    passthrough,
+    displayMode = DEFAULT_SIMULATOR_DISPLAY_MODE,
+    env: extraEnv,
+    simctlImpl,
+    flowRunner,
+    simPreparer,
+    pollIntervalMs,
+    flowWaitDeadlineMs
+  } = opts;
+  installTraps();
+  const simctl = simctlImpl ?? await getDefaultSimctl();
+  initRunRecord({
+    config,
+    runId,
+    agent,
+    appPath: appResolved.appPath,
+    flows
+  });
+  updateRunRecord(config, runId, { state: "running" });
+  try {
+    const results = await runFlowsConcurrently({
+      runId,
+      agent,
+      flows,
+      appResolved,
+      config,
+      passthrough,
+      displayMode,
+      ...extraEnv !== undefined ? { env: extraEnv } : {},
+      simctl,
+      ...flowRunner !== undefined ? { flowRunner } : {},
+      ...simPreparer !== undefined ? { simPreparer } : {},
+      ...pollIntervalMs !== undefined ? { pollIntervalMs } : {},
+      ...flowWaitDeadlineMs !== undefined ? { flowWaitDeadlineMs } : {},
+      onResultsChanged: (resultsSnapshot) => {
+        updateRunRecord(config, runId, { summary: [...resultsSnapshot] });
+      }
+    });
+    removeTicket(config, runId);
+    const finalState = results.some((result) => result.result === "FAIL") ? "failed" : "passed";
+    updateRunRecord(config, runId, {
+      state: finalState,
+      summary: [...results]
+    });
+    return {
+      runId,
+      state: finalState,
+      results
+    };
+  } catch (error) {
+    removeTicket(config, runId);
+    updateRunRecord(config, runId, { state: "failed" });
+    throw error;
+  }
+}
+async function getDefaultSimctl() {
+  const simctlModule = await Promise.resolve().then(() => (init_simctl(), exports_simctl));
+  return simctlModule;
+}
+
+// src/log-redaction.ts
+var REDACTED_VALUE = "<redacted>";
+var SENSITIVE_KEY_PATTERN = /(?:token|secret|password|auth|bearer|api[_-]?key)/i;
+var AUTHORIZATION_HEADER_PATTERN = /\bAuthorization\s*:\s*[^\s"',;]+(?:\s+[^\s"',;]+)?/gi;
+var BEARER_TOKEN_PATTERN = /\bBearer\s+[^\s"',;]+/gi;
+var SECRET_ASSIGNMENT_PATTERN = /(^|[\s"'[{,(])([A-Za-z0-9_.-]*(?:token|secret|password|auth|bearer|api[_-]?key)[A-Za-z0-9_.-]*)=([^\s"',\]}]+)/gi;
+function redactSensitiveText(text) {
+  return text.replace(AUTHORIZATION_HEADER_PATTERN, "Authorization: <redacted>").replace(BEARER_TOKEN_PATTERN, `Bearer ${REDACTED_VALUE}`).replace(SECRET_ASSIGNMENT_PATTERN, (_match, prefix, key) => {
+    return `${prefix}${key}=${REDACTED_VALUE}`;
+  });
+}
+function redactSensitiveArgs(args) {
+  return args.map(redactSensitiveArgument);
+}
+function redactSensitiveArgument(arg) {
+  const separatorIndex = arg.indexOf("=");
+  if (separatorIndex <= 0) {
+    return redactSensitiveText(arg);
+  }
+  const key = arg.slice(0, separatorIndex);
+  if (SENSITIVE_KEY_PATTERN.test(key)) {
+    return `${key}=${REDACTED_VALUE}`;
+  }
+  return redactSensitiveText(arg);
+}
+// src/testFlowSelection.ts
+import { existsSync as existsSync7, readdirSync as readdirSync5, readFileSync as readFileSync4 } from "fs";
+import { join as join12 } from "path";
+
+// src/rerunFailed.ts
+import { basename as basename4 } from "path";
+class RerunFailedSelectionError extends Error {
+  name = "RerunFailedSelectionError";
+}
+function selectRerunFailedFlows(opts) {
+  const currentFlowsByName = flowLookup(opts.currentFullSuiteFlows);
+  const source = opts.fromRunId === undefined ? selectLatestFailedFullSuiteRun(opts.config, currentFlowsByName) : selectExplicitRun(opts.config, opts.fromRunId);
+  return {
+    runId: source.runId,
+    flows: failedFlowsFromRun(source, currentFlowsByName, opts.config)
+  };
+}
+function selectExplicitRun(config, runId) {
+  const record = readJsonOrNull(runRecordPath(config, runId));
+  if (record === null) {
+    throw new RerunFailedSelectionError(`rerun-failed: run ${runId} was not found in pool ${config.pool.prefix}`);
+  }
+  return { runId, record };
+}
+function selectLatestFailedFullSuiteRun(config, currentFlowsByName) {
+  const index = readJsonOrNull(runsIndexPath(config)) ?? [];
+  for (const entry of index.slice().reverse()) {
+    if (entry.state !== "failed") {
+      continue;
+    }
+    const source = selectExplicitRun(config, entry.runId);
+    if (isFullSuiteRun(source.record, currentFlowsByName)) {
+      return source;
+    }
+  }
+  throw new RerunFailedSelectionError(`rerun-failed: no failed full-suite runs found for pool ${config.pool.prefix}; use --from-run <runId> to select a run explicitly`);
+}
+function isFullSuiteRun(record, currentFlowsByName) {
+  if (record.flows.length !== currentFlowsByName.size) {
+    return false;
+  }
+  return record.flows.every((flow) => currentFlowsByName.has(basename4(flow)));
+}
+function failedFlowsFromRun(source, currentFlowsByName, config) {
+  const recordFlowNames = new Set(source.record.flows.map((flow) => basename4(flow)));
+  const failedFlows = [];
+  for (const result of source.record.summary) {
+    if (result.result !== "FAIL") {
+      continue;
+    }
+    if (!recordFlowNames.has(result.flow)) {
+      throw new RerunFailedSelectionError(`rerun-failed: run ${source.runId} summary references failed flow ${result.flow} that is not listed in run.json flows`);
+    }
+    const currentFlow = currentFlowsByName.get(result.flow);
+    if (currentFlow === undefined) {
+      throw new RerunFailedSelectionError(`rerun-failed: run ${source.runId} is incompatible with the current pool/config: failed flow ${result.flow} is not in ${config.flowsDir}`);
+    }
+    failedFlows.push(currentFlow);
+  }
+  if (failedFlows.length === 0) {
+    throw new RerunFailedSelectionError(`rerun-failed: run ${source.runId} has no failed flows`);
+  }
+  return failedFlows;
+}
+function flowLookup(flows) {
+  const lookup = new Map;
+  for (const flow of flows) {
+    lookup.set(basename4(flow), flow);
+  }
+  return lookup;
+}
+
+// src/testFlowSelection.ts
+function readFlowTags(flowPath) {
+  const tags = [];
+  let text;
+  try {
+    text = readFileSync4(flowPath, { encoding: "utf8" });
+  } catch {
+    return tags;
+  }
+  let inTagsBlock = false;
+  for (const line of text.split(`
+`)) {
+    if (/^tags:\s*$/.test(line)) {
+      inTagsBlock = true;
+      continue;
+    }
+    if (inTagsBlock) {
+      const m = line.match(/^\s+-\s+(.+)$/);
+      const tag = m?.[1];
+      if (tag !== undefined) {
+        tags.push(tag.trim());
+      } else if (line.trim() !== "" && !/^\s+/.test(line)) {
+        inTagsBlock = false;
+      }
+    }
+  }
+  return tags;
+}
+function listFlows(flowsDir) {
+  if (!existsSync7(flowsDir))
+    return [];
+  try {
+    return readdirSync5(flowsDir).filter((f) => f.endsWith(".yaml") || f.endsWith(".yml")).sort().map((f) => join12(flowsDir, f));
+  } catch {
+    return [];
+  }
+}
+function filterFlowsByTags(flows, includeTags, excludeTags) {
+  if (includeTags.length === 0 && excludeTags.length === 0)
+    return [...flows];
+  return flows.filter((flowPath) => {
+    const tags = readFlowTags(flowPath);
+    if (includeTags.length > 0) {
+      const hasInclude = includeTags.some((t) => tags.includes(t));
+      if (!hasInclude)
+        return false;
+    }
+    if (excludeTags.length > 0) {
+      const hasExclude = excludeTags.some((t) => tags.includes(t));
+      if (hasExclude)
+        return false;
+    }
+    return true;
+  });
+}
+function selectTestFlows(opts) {
+  if (opts.fromRunId !== undefined && !opts.rerunFailed) {
+    throw new RerunFailedSelectionError("--from-run requires --rerun-failed");
+  }
+  if (opts.rerunFailed) {
+    return selectRerunFlows(opts);
+  }
+  const fullSuite = opts.requestedFlows.length === 0 && opts.includeTags.length === 0 && opts.excludeTags.length === 0;
+  const baseFlows = opts.requestedFlows.length > 0 ? [...opts.requestedFlows] : listFlows(opts.config.flowsDir);
+  return {
+    flows: filterFlowsByTags(baseFlows, opts.includeTags, opts.excludeTags),
+    fullSuite
+  };
+}
+function selectRerunFlows(opts) {
+  if (opts.requestedFlows.length > 0) {
+    throw new RerunFailedSelectionError("--rerun-failed cannot be combined with positional flow arguments");
+  }
+  if (opts.includeTags.length > 0 || opts.excludeTags.length > 0) {
+    throw new RerunFailedSelectionError("--rerun-failed cannot be combined with --include-tags or --exclude-tags");
+  }
+  const selection = selectRerunFailedFlows({
+    config: opts.config,
+    fromRunId: opts.fromRunId,
+    currentFullSuiteFlows: listFlows(opts.config.flowsDir)
+  });
+  return {
+    flows: selection.flows,
+    fullSuite: false,
+    rerunSourceRunId: selection.runId
+  };
+}
+
+// src/commands/test.ts
+async function runTest(opts) {
+  const { config, agent, passthrough, simctlImpl, flowRunner, simPreparer } = opts;
+  const flowSelection = selectTestFlows({
+    config,
+    requestedFlows: opts.flows,
+    includeTags: opts.includeTags,
+    excludeTags: opts.excludeTags,
+    rerunFailed: opts.rerunFailed === true,
+    fromRunId: opts.fromRunId
+  });
+  const flows = flowSelection.flows;
+  if (flowSelection.rerunSourceRunId !== undefined) {
+    process.stderr.write(`[maestro-manager] test: rerun-failed from ${flowSelection.rerunSourceRunId}, failedFlows=${flows.length}
+`);
+  }
+  if (flows.length === 0) {
+    process.stderr.write(`[maestro-manager] test: no flows to run.
+`);
+    return 0;
+  }
+  let simsCount = opts.sims ?? config.pool.default;
+  if (simsCount > config.pool.max) {
+    process.stderr.write(`[maestro-manager] test: --sims ${simsCount} exceeds pool.max ${config.pool.max}; clamped.
+`);
+    simsCount = config.pool.max;
+  }
+  const appResolved = await resolveApp({
+    explicitApp: opts.appPath,
+    config: config.app,
+    flow: flows[0]
+  });
+  const runId = `run-${Date.now()}-${randomUUID2().slice(0, 8)}`;
+  const reservation = flowSelection.fullSuite ? fullSuiteReservationRecord({
+    agent,
+    runId,
+    requestedLaneCount: simsCount
+  }) : null;
+  if (reservation !== null) {
+    const reserved = await reserveFullSuite(config, reservation);
+    if (!reserved) {
+      process.stderr.write(`[maestro-manager] test: another full-suite reservation is active; retry later.
+`);
+      return 1;
+    }
+  }
+  process.stderr.write(`[maestro-manager] test: runId=${runId}, flows=${flows.length}, sims=${simsCount}, passthrough=${JSON.stringify(redactSensitiveArgs(passthrough))}
+`);
+  const runWorkerOpts = {
+    runId,
+    agent,
+    flows,
+    appResolved,
+    config: { ...config, pool: { ...config.pool, default: simsCount } },
+    passthrough,
+    displayMode: opts.displayMode ?? DEFAULT_SIMULATOR_DISPLAY_MODE,
+    ...simctlImpl !== undefined ? { simctlImpl } : {},
+    ...flowRunner !== undefined ? { flowRunner } : {},
+    ...simPreparer !== undefined ? { simPreparer } : {}
+  };
+  try {
+    const summary = await runWorker(runWorkerOpts);
+    printResultTable(summary.results);
+    return summary.state === "passed" ? 0 : 1;
+  } finally {
+    if (reservation !== null) {
+      await releaseFullSuiteReservation(config, reservation.runId, reservation.ownerPid);
+    }
+  }
+}
+function printResultTable(results) {
+  const maxFlow = Math.max(4, ...results.map((r) => basename5(r.flow).length));
+  const maxSim = Math.max(3, ...results.map((r) => r.sim.length));
+  const header = `${"FLOW".padEnd(maxFlow)}  ${"SIM".padEnd(maxSim)}  RESULT`;
+  const sep = "-".repeat(header.length);
+  process.stdout.write(`
+${header}
+${sep}
+`);
+  for (const r of results) {
+    const name = basename5(r.flow).padEnd(maxFlow);
+    const sim = r.sim.padEnd(maxSim);
+    const mark = r.result === "PASS" ? "PASS" : "FAIL";
+    process.stdout.write(`${name}  ${sim}  ${mark}
+`);
+  }
+  const passed = results.filter((r) => r.result === "PASS").length;
+  const failed = results.filter((r) => r.result === "FAIL").length;
+  process.stdout.write(`${sep}
+${passed} passed, ${failed} failed
+
+`);
+}
+function fullSuiteReservationRecord(opts) {
+  const now = new Date().toISOString();
+  return {
+    ownerPid: process.pid,
+    ownerStart: processStartTime(process.pid) ?? "",
+    bootId: machineBootId(),
+    worktree: opts.agent,
+    runId: opts.runId,
+    requestedLaneCount: opts.requestedLaneCount,
+    reservedAt: now,
+    heartbeatAt: now
+  };
+}
+
+// src/commands/status.ts
+import { readdirSync as readdirSync6, statSync as statSync11 } from "fs";
+import { join as join13 } from "path";
+init_simctl();
+async function runStatus(opts) {
+  const { config, simctlImpl = exports_simctl } = opts;
+  let poolState = null;
+  try {
+    poolState = await reconcile(config, simctlImpl);
+  } catch {
+    poolState = null;
+  }
+  process.stdout.write(`
+=== Pool Sims ===
+`);
+  if (poolState === null) {
+    process.stdout.write(`  (simctl unavailable \u2014 cannot list devices)
+`);
+  } else if (poolState.slots.length === 0) {
+    process.stdout.write("  (no pool sims \u2014 run `maestro-manager up` first)\n");
+  } else {
+    const maxName = Math.max(4, ...poolState.slots.map((s) => s.simName.length));
+    const maxUdid = Math.max(4, ...poolState.slots.map((s) => s.udid.length));
+    process.stdout.write(`${"NAME".padEnd(maxName)}  ${"UDID".padEnd(maxUdid)}  STATE      LEASED
+`);
+    process.stdout.write("-".repeat(maxName + maxUdid + 20) + `
+`);
+    for (const slot of poolState.slots) {
+      const leased = slot.leased ? "yes" : "no";
+      process.stdout.write(`${slot.simName.padEnd(maxName)}  ${slot.udid.padEnd(maxUdid)}  ${slot.state.padEnd(10)} ${leased}
+`);
+    }
+  }
+  process.stdout.write(`
+=== Active Leases ===
+`);
+  const leases = readAllLeases(config);
+  if (leases.length === 0) {
+    process.stdout.write(`  (none)
+`);
+  } else {
+    for (const { simName, record } of leases) {
+      const since = formatRelativeTime(record.leasedAt);
+      const hb = formatRelativeTime(record.heartbeatAt);
+      process.stdout.write(`  ${simName}
+`);
+      process.stdout.write(`    worktree: ${record.worktree}
+`);
+      process.stdout.write(`    flow:     ${record.flow}
+`);
+      process.stdout.write(`    pid:      ${record.ownerPid}
+`);
+      process.stdout.write(`    leased:   ${since} ago
+`);
+      process.stdout.write(`    heartbeat:${hb} ago
+`);
+    }
+  }
+  process.stdout.write(`
+=== Full-Suite Reservation ===
+`);
+  const reservation = readFullSuiteReservation(config);
+  if (reservation === null) {
+    process.stdout.write(`  (none)
+`);
+  } else {
+    const age = formatRelativeTime(reservation.reservedAt);
+    process.stdout.write(`  owner:    ${reservation.worktree}
+`);
+    process.stdout.write(`  run id:   ${reservation.runId}
+`);
+    process.stdout.write(`  lanes:    ${reservation.requestedLaneCount}
+`);
+    process.stdout.write(`  age:      ${age} ago
+`);
+    process.stdout.write(`  pid:      ${reservation.ownerPid}
+`);
+  }
+  process.stdout.write(`
+=== Recent Runs ===
+`);
+  const indexPath = runsIndexPath(config);
+  const index = readJsonOrNull(indexPath);
+  if (index === null || index.length === 0) {
+    process.stdout.write(`  (no runs recorded)
+`);
+  } else {
+    const recent = index.slice(-10).reverse();
+    for (const entry of recent) {
+      const runRecord = readJsonOrNull(runRecordPath(config, entry.runId));
+      const flowCount = runRecord?.flows?.length ?? "?";
+      const summaryCount = runRecord?.summary?.length ?? "?";
+      const since = formatRelativeTime(entry.updatedAt);
+      process.stdout.write(`  [${entry.state.padEnd(7)}] ${entry.runId}  ${summaryCount}/${flowCount} flows  ${since} ago
+`);
+    }
+  }
+  process.stdout.write(`
+`);
+}
+function readAllLeases(config) {
+  const result = [];
+  const simsDir = join13(poolRoot(config), "sims");
+  let entries;
+  try {
+    entries = readdirSync6(simsDir);
+  } catch {
+    return result;
+  }
+  for (const simName of entries) {
+    const leaseDirPath = simLeaseDir(config, simName);
+    const recordPath = simLeaseRecordPath(config, simName);
+    let dirExists = false;
+    try {
+      dirExists = statSync11(leaseDirPath).isDirectory();
+    } catch {
+      continue;
+    }
+    if (!dirExists)
+      continue;
+    const record = readJsonOrNull(recordPath);
+    if (record !== null) {
+      result.push({ simName, record });
+    }
+  }
+  return result;
+}
+function formatRelativeTime(isoOrEpoch) {
+  if (!isoOrEpoch)
+    return "?";
+  const t = Date.parse(isoOrEpoch);
+  if (Number.isNaN(t))
+    return "?";
+  const diffMs = Date.now() - t;
+  const secs = Math.floor(diffMs / 1000);
+  if (secs < 60)
+    return `${secs}s`;
+  const mins = Math.floor(secs / 60);
+  if (mins < 60)
+    return `${mins}m`;
+  const hours = Math.floor(mins / 60);
+  return `${hours}h${mins % 60}m`;
+}
+
+// src/commands/stop.ts
+import { readdirSync as readdirSync7, statSync as statSync12, rmSync as rmSync8, readFileSync as readFileSync5 } from "fs";
+import { join as join14 } from "path";
+init_simctl();
+async function runStop(opts) {
+  const { config, scope } = opts;
+  const inScope = collectInScopeLeases(config, scope);
+  if (inScope.length === 0) {
+    process.stderr.write(`[maestro-manager] stop: no in-scope leases found.
+`);
+    return;
+  }
+  for (const { simName, record, udid } of inScope) {
+    const currentRecord = readMatchingLeaseRecord(config, simName, record);
+    if (currentRecord === null) {
+      process.stderr.write(`[maestro-manager] stop: ${simName} owner changed \u2014 skipping signal and reclaim
+`);
+      continue;
+    }
+    if (isOwnerLive(currentRecord)) {
+      const signalRecord = readMatchingLeaseRecord(config, simName, record);
+      if (signalRecord === null) {
+        process.stderr.write(`[maestro-manager] stop: ${simName} owner changed \u2014 skipping signal and reclaim
+`);
+        continue;
+      }
+      process.stderr.write(`[maestro-manager] stop: stopping ${simName} (pid=${signalRecord.ownerPid}, flow=${signalRecord.flow})
+`);
+      try {
+        process.kill(signalRecord.ownerPid, "SIGTERM");
+      } catch (error) {
+        if (!(error instanceof Error)) {
+          throw error;
+        }
+      }
+      const deadline = Date.now() + 5000;
+      while (readMatchingLiveLeaseRecord(config, simName, record) !== null && Date.now() < deadline) {
+        await sleep3(200);
+      }
+      const killRecord = readMatchingLiveLeaseRecord(config, simName, record);
+      if (killRecord !== null) {
+        try {
+          process.kill(killRecord.ownerPid, "SIGKILL");
+        } catch (error) {
+          if (!(error instanceof Error)) {
+            throw error;
+          }
+        }
+        await sleep3(500);
+      }
+      const maestroRecord = readMatchingLeaseRecord(config, simName, record);
+      if (maestroRecord !== null && maestroRecord.maestroPid > 0 && !pidIsDead(maestroRecord.maestroPid)) {
+        try {
+          process.kill(-maestroRecord.maestroPid, "SIGKILL");
+        } catch (error) {
+          if (!(error instanceof Error)) {
+            throw error;
+          }
+          try {
+            process.kill(maestroRecord.maestroPid, "SIGKILL");
+          } catch (fallbackError) {
+            if (!(fallbackError instanceof Error)) {
+              throw fallbackError;
+            }
+          }
+        }
+      }
+    } else {
+      process.stderr.write(`[maestro-manager] stop: ${simName} owner is stale \u2014 skipping signal
+`);
+    }
+    await withPoolLock(config, () => {
+      const recordNow = readJsonOrNull(simLeaseRecordPath(config, simName));
+      if (recordNow === null)
+        return;
+      if (!ownerIdentitiesMatch(record, recordNow))
+        return;
+      if (isOwnerLive(recordNow)) {
+        process.stderr.write(`[maestro-manager] stop: pid ${recordNow.ownerPid} still alive \u2014 skipping reclaim of ${simName}
+`);
+        return;
+      }
+      try {
+        rmSync8(simLeaseDir(config, simName), { recursive: true, force: true });
+        process.stderr.write(`[maestro-manager] stop: reclaimed lease for ${simName}
+`);
+      } catch (error) {
+        if (!(error instanceof Error)) {
+          throw error;
+        }
+      }
+    });
+    if (udid !== "") {
+      try {
+        await shutdown(udid);
+        process.stderr.write(`[maestro-manager] stop: shut down ${simName} (${udid})
+`);
+      } catch (error) {
+        if (!(error instanceof Error)) {
+          throw error;
+        }
+      }
+    }
+  }
+}
+function collectInScopeLeases(config, scope) {
+  const result = [];
+  const simsDir = join14(poolRoot(config), "sims");
+  let entries;
+  try {
+    entries = readdirSync7(simsDir);
+  } catch (error) {
+    if (!(error instanceof Error)) {
+      throw error;
+    }
+    return result;
+  }
+  for (const simName of entries) {
+    const leaseDirPath = simLeaseDir(config, simName);
+    const recordPath = simLeaseRecordPath(config, simName);
+    let dirExists = false;
+    try {
+      dirExists = statSync12(leaseDirPath).isDirectory();
+    } catch (error) {
+      if (!(error instanceof Error)) {
+        throw error;
+      }
+      continue;
+    }
+    if (!dirExists)
+      continue;
+    const record = readJsonOrNull(recordPath);
+    if (record === null)
+      continue;
+    const inScope = scopeMatches(scope, record);
+    if (!inScope)
+      continue;
+    const udidPath = join14(poolRoot(config), "sims", simName, "udid");
+    let udid = "";
+    try {
+      udid = readFileSync5(udidPath, { encoding: "utf8" }).trim();
+    } catch (error) {
+      if (!(error instanceof Error)) {
+        throw error;
+      }
+    }
+    result.push({ simName, record, udid });
+  }
+  return result;
+}
+function readMatchingLiveLeaseRecord(config, simName, expected) {
+  const record = readMatchingLeaseRecord(config, simName, expected);
+  if (record === null)
+    return null;
+  return isOwnerLive(record) ? record : null;
+}
+function readMatchingLeaseRecord(config, simName, expected) {
+  const record = readJsonOrNull(simLeaseRecordPath(config, simName));
+  if (record === null)
+    return null;
+  return ownerIdentitiesMatch(expected, record) ? record : null;
+}
+function scopeMatches(scope, record) {
+  switch (scope.kind) {
+    case "mine":
+      return record.worktree === scope.worktree;
+    case "worktree":
+      return record.worktree === scope.worktree;
+    case "all":
+      return true;
+  }
+}
+function sleep3(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+
+// src/commands/down.ts
+import { rmSync as rmSync9, readdirSync as readdirSync8, readFileSync as readFileSync6 } from "fs";
+import { join as join15 } from "path";
+init_simctl();
+async function runDown(opts) {
+  const { config, agent } = opts;
+  const simctlImpl = opts.simctlImpl ?? exports_simctl;
+  const root = poolRoot(config);
+  process.stderr.write(`[maestro-manager] down: stopping all leases...
+`);
+  await runStop({
+    config,
+    scope: { kind: "all" }
+  });
+  process.stderr.write(`[maestro-manager] down: deleting pool sims...
+`);
+  let poolState = null;
+  try {
+    poolState = await reconcile(config, simctlImpl);
+  } catch (error) {
+    if (!(error instanceof Error)) {
+      throw error;
+    }
+    poolState = null;
+  }
+  if (poolState !== null) {
+    await Promise.all(poolState.slots.map(async (slot) => {
+      try {
+        process.stderr.write(`[maestro-manager] down: deleting ${slot.simName} (${slot.udid})...
+`);
+        await simctlImpl.deleteDevice(slot.udid);
+      } catch (err) {
+        if (!(err instanceof Error)) {
+          throw err;
+        }
+        process.stderr.write(`[maestro-manager] down: could not delete ${slot.simName}: ${err.message}
+`);
+      }
+    }));
+  } else {
+    const simsDir = join15(root, "sims");
+    let entries;
+    try {
+      entries = readdirSync8(simsDir);
+    } catch (error) {
+      if (!(error instanceof Error)) {
+        throw error;
+      }
+      entries = [];
+    }
+    await Promise.all(entries.map(async (simName) => {
+      const udidPath = join15(root, "sims", simName, "udid");
+      let udid = "";
+      try {
+        udid = readFileSync6(udidPath, { encoding: "utf8" }).trim();
+      } catch (error) {
+        if (!(error instanceof Error)) {
+          throw error;
+        }
+        return;
+      }
+      if (!udid)
+        return;
+      try {
+        process.stderr.write(`[maestro-manager] down: deleting ${simName} (${udid})...
+`);
+        await simctlImpl.deleteDevice(udid);
+      } catch (err) {
+        if (!(err instanceof Error)) {
+          throw err;
+        }
+        process.stderr.write(`[maestro-manager] down: could not delete ${simName}: ${err.message}
+`);
+      }
+    }));
+  }
+  process.stderr.write(`[maestro-manager] down: clearing state...
+`);
+  const safeRoot = assertPoolRootContained(root);
+  try {
+    rmSync9(safeRoot, { recursive: true, force: true });
+    process.stderr.write(`[maestro-manager] down: cleared ${safeRoot}
+`);
+  } catch (err) {
+    if (!(err instanceof Error)) {
+      throw err;
+    }
+    process.stderr.write(`[maestro-manager] down: could not clear state: ${err.message}
+`);
+  }
+}
+
+// src/commands/clean.ts
+import { readdirSync as readdirSync9, statSync as statSync13, readFileSync as readFileSync7 } from "fs";
+import { join as join16 } from "path";
+import { execFileSync as execFileSync6 } from "child_process";
+init_simctl();
+async function runClean(opts) {
+  const { config, idleShutdownMinutes, idleDeleteHours, pruneAccounts, deleteUnavailable: deleteUnavailable2 } = opts;
+  const simctlImpl = opts.simctlImpl ?? exports_simctl;
+  const killMaestro = opts.killMaestro ?? killMaestroGroup;
+  process.stderr.write(`[maestro-manager] clean: reaping orphaned runs...
+`);
+  const reapedCount = await reapOrphanedRuns(config, simctlImpl, killMaestro);
+  process.stderr.write(`[maestro-manager] clean: reaped ${reapedCount} orphaned run(s).
+`);
+  process.stderr.write(`[maestro-manager] clean: reclaiming stale leases...
+`);
+  const reclaimedCount = await reclaimAllStaleLeases(config, simctlImpl);
+  process.stderr.write(`[maestro-manager] clean: reclaimed ${reclaimedCount} stale lease(s).
+`);
+  if (idleShutdownMinutes !== undefined || idleDeleteHours !== undefined) {
+    await idleReap({ config, idleShutdownMinutes, idleDeleteHours, simctlImpl });
+  }
+  if (pruneAccounts === true) {
+    await runPruneAccounts(config);
+  }
+  if (deleteUnavailable2 === true) {
+    process.stderr.write(`[maestro-manager] clean --delete-unavailable: deleting unavailable CoreSimulator devices (GLOBAL)...
+`);
+    try {
+      await simctlImpl.deleteUnavailable();
+      process.stderr.write(`[maestro-manager] clean --delete-unavailable: done.
+`);
+    } catch (error) {
+      if (!(error instanceof Error)) {
+        throw error;
+      }
+      process.stderr.write(`[maestro-manager] clean --delete-unavailable: failed: ${error.message}
+`);
+    }
+  }
+}
+function readUdid(config, simName) {
+  try {
+    const raw = readFileSync7(simUdidPath(config, simName), { encoding: "utf8" }).trim();
+    return raw.length > 0 ? raw : null;
+  } catch (error) {
+    if (!(error instanceof Error)) {
+      throw error;
+    }
+    return null;
+  }
+}
+async function reapOrphanedRuns(config, simctlImpl, killMaestro) {
+  const simsDir = join16(poolRoot(config), "sims");
+  let entries;
+  try {
+    entries = readdirSync9(simsDir);
+  } catch (error) {
+    if (!(error instanceof Error)) {
+      throw error;
+    }
+    return 0;
+  }
+  let count = 0;
+  for (const simName of entries) {
+    const leaseDirPath = simLeaseDir(config, simName);
+    let dirExists = false;
+    try {
+      dirExists = statSync13(leaseDirPath).isDirectory();
+    } catch (error) {
+      if (!(error instanceof Error)) {
+        throw error;
+      }
+      continue;
+    }
+    if (!dirExists)
+      continue;
+    const udid = readUdid(config, simName);
+    const reaped = await reapOrphanIfAlive(config, simName, killMaestro);
+    if (reaped) {
+      process.stderr.write(`[maestro-manager] clean: reaped orphaned run on ${simName} (killed orphaned maestro group).
+`);
+      count++;
+      if (udid !== null) {
+        await shutdownBestEffort(simctlImpl, simName, udid);
+      }
+    }
+  }
+  return count;
+}
+async function shutdownBestEffort(simctlImpl, simName, udid) {
+  try {
+    await simctlImpl.shutdown(udid);
+  } catch (error) {
+    if (!(error instanceof Error)) {
+      throw error;
+    }
+    process.stderr.write(`[maestro-manager] clean: could not shut down ${simName}: ${error.message}
+`);
+  }
+}
+async function reclaimAllStaleLeases(config, simctlImpl) {
+  const simsDir = join16(poolRoot(config), "sims");
+  let entries;
+  try {
+    entries = readdirSync9(simsDir);
+  } catch (error) {
+    if (!(error instanceof Error)) {
+      throw error;
+    }
+    return 0;
+  }
+  let count = 0;
+  for (const simName of entries) {
+    const leaseDirPath = simLeaseDir(config, simName);
+    let dirExists = false;
+    try {
+      dirExists = statSync13(leaseDirPath).isDirectory();
+    } catch (error) {
+      if (!(error instanceof Error)) {
+        throw error;
+      }
+      continue;
+    }
+    if (!dirExists)
+      continue;
+    const udid = readUdid(config, simName);
+    const reclaimed = await reclaimIfStale(config, simName);
+    if (reclaimed) {
+      process.stderr.write(`[maestro-manager] clean: reclaimed stale lease for ${simName}
+`);
+      count++;
+      if (udid !== null) {
+        await shutdownBestEffort(simctlImpl, simName, udid);
+      }
+    }
+  }
+  return count;
+}
+async function idleReap(opts) {
+  const { config, idleShutdownMinutes, idleDeleteHours, simctlImpl } = opts;
+  const simsDir = join16(poolRoot(config), "sims");
+  let entries;
+  try {
+    entries = readdirSync9(simsDir);
+  } catch (error) {
+    if (!(error instanceof Error)) {
+      throw error;
+    }
+    return;
+  }
+  const nowSecs = Math.floor(Date.now() / 1000);
+  let liveDevices = [];
+  try {
+    const allDevices = await simctlImpl.listDevices();
+    const prefix = config.pool.prefix;
+    liveDevices = allDevices.filter((d) => d.name.startsWith(`${prefix}-`));
+  } catch (error) {
+    if (!(error instanceof Error)) {
+      throw error;
+    }
+    process.stderr.write(`[maestro-manager] clean: simctl unavailable \u2014 skipping idle reap.
+`);
+    return;
+  }
+  await Promise.all(entries.map(async (simName) => {
+    const leaseDirPath = simLeaseDir(config, simName);
+    let isLeased = false;
+    try {
+      isLeased = statSync13(leaseDirPath).isDirectory();
+    } catch (error) {
+      if (!(error instanceof Error)) {
+        throw error;
+      }
+    }
+    if (isLeased) {
+      const record = readJsonOrNull(simLeaseRecordPath(config, simName));
+      if (record !== null) {
+        process.stderr.write(`[maestro-manager] clean: ${simName} is live-leased \u2014 skipping.
+`);
+        return;
+      }
+    }
+    const lastUsedPath = simLastUsedPath(config, simName);
+    let lastUsedSecs = null;
+    try {
+      const raw = readFileSync7(lastUsedPath, { encoding: "utf8" }).trim();
+      const n = parseInt(raw, 10);
+      if (!Number.isNaN(n))
+        lastUsedSecs = n;
+    } catch (error) {
+      if (!(error instanceof Error)) {
+        throw error;
+      }
+    }
+    const idleSecs = lastUsedSecs !== null ? nowSecs - lastUsedSecs : null;
+    const device = liveDevices.find((d) => d.name === simName);
+    if (!device)
+      return;
+    const { udid, state } = device;
+    if (idleDeleteHours !== undefined && idleSecs !== null) {
+      const idleHours = idleSecs / 3600;
+      if (idleHours > idleDeleteHours) {
+        process.stderr.write(`[maestro-manager] clean: ${simName} idle ${idleHours.toFixed(1)}h > ${idleDeleteHours}h \u2014 deleting.
+`);
+        try {
+          if (state === "Booted")
+            await simctlImpl.shutdown(udid);
+          await simctlImpl.deleteDevice(udid);
+        } catch (err) {
+          if (!(err instanceof Error)) {
+            throw err;
+          }
+          process.stderr.write(`[maestro-manager] clean: could not delete ${simName}: ${err.message}
+`);
+        }
+        return;
+      }
+    }
+    if (idleShutdownMinutes !== undefined && idleSecs !== null) {
+      const idleMinutes = idleSecs / 60;
+      if (idleMinutes > idleShutdownMinutes && state === "Booted") {
+        process.stderr.write(`[maestro-manager] clean: ${simName} idle ${idleMinutes.toFixed(0)}m > ${idleShutdownMinutes}m \u2014 shutting down.
+`);
+        try {
+          await simctlImpl.shutdown(udid);
+        } catch (err) {
+          if (!(err instanceof Error)) {
+            throw err;
+          }
+          process.stderr.write(`[maestro-manager] clean: could not shut down ${simName}: ${err.message}
+`);
+        }
+      }
+    }
+  }));
+}
+async function runPruneAccounts(config) {
+  const cmd = config.hooks.pruneAccounts;
+  if (!cmd || cmd.trim() === "") {
+    process.stderr.write(`[maestro-manager] clean --prune-accounts: no hooks.pruneAccounts configured.
+`);
+    return;
+  }
+  process.stderr.write(`[maestro-manager] clean --prune-accounts: running configured hook.
+`);
+  try {
+    const output = execFileSync6("sh", ["-c", cmd], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: 30000
+    });
+    process.stdout.write(output);
+    process.stderr.write(`[maestro-manager] clean --prune-accounts: done.
+`);
+  } catch (err) {
+    if (!(err instanceof Error)) {
+      throw err;
+    }
+    const status = "status" in err && typeof err.status === "number" ? err.status : 1;
+    const stderr = "stderr" in err && typeof err.stderr === "string" ? err.stderr : err.message;
+    process.stderr.write(`[maestro-manager] clean --prune-accounts: command failed (exit ${status}): ${redactSensitiveText(stderr)}
+`);
+  }
+}
+// src/cliArgPrimitives.ts
+var SAFE_POSITIVE_INTEGER_TOKEN = /^[1-9][0-9]*$/;
+var MANAGER_FLAGS = new Set([
+  "--all",
+  "--app",
+  "--config",
+  "--delete-unavailable",
+  "--exclude-tags",
+  "--from-run",
+  "--headed",
+  "--headless",
+  "--help",
+  "--idle-delete",
+  "--idle-shutdown",
+  "--include-tags",
+  "--keep",
+  "--mine",
+  "--prune-accounts",
+  "--rerun-failed",
+  "--sims",
+  "--version",
+  "--worktree",
+  "-h",
+  "-v"
+]);
+
+class CliUsageError extends Error {
+  name = "CliUsageError";
+}
+function splitAtDoubleDash(args) {
+  const index = args.indexOf("--");
+  if (index === -1)
+    return { head: args.slice(), passthrough: [] };
+  return { head: args.slice(0, index), passthrough: args.slice(index + 1) };
+}
+function isManagerFlagToken(token) {
+  return token.startsWith("--") || /^-[A-Za-z]/.test(token);
+}
+function readRequiredValue(args, index, flag) {
+  const value = args[index + 1];
+  if (value === undefined) {
+    throw new CliUsageError(`${flag} requires a value`);
+  }
+  if (MANAGER_FLAGS.has(value)) {
+    throw new CliUsageError(`${flag} requires a value before ${value}`);
+  }
+  if (isManagerFlagToken(value)) {
+    throw new CliUsageError(`unknown manager flag: ${value}`);
+  }
+  return value;
+}
+function rejectDuplicate(currentValue, flag) {
+  if (currentValue !== undefined) {
+    throw new CliUsageError(`${flag} may only be specified once`);
+  }
+}
+function parsePositiveInteger(flag, value) {
+  if (!SAFE_POSITIVE_INTEGER_TOKEN.test(value)) {
+    throw new CliUsageError(`${flag} must be a positive integer (got: ${value})`);
+  }
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed)) {
+    throw new CliUsageError(`${flag} must be a positive integer (got: ${value})`);
+  }
+  return parsed;
+}
+function splitTags(value) {
+  return value.split(",").map((tag) => tag.trim()).filter((tag) => tag.length > 0);
+}
+
+// src/cliArgs.ts
+function parseManagerArgv(args) {
+  const { head, passthrough } = splitAtDoubleDash(args);
+  const state = {
+    positionals: [],
+    passthrough,
+    configPath: undefined,
+    appPath: undefined,
+    sims: undefined,
+    includeTags: [],
+    excludeTags: [],
+    rerunFailed: false,
+    fromRunId: undefined,
+    keep: false,
+    mine: false,
+    all: false,
+    worktreePath: undefined,
+    idleShutdownMinutes: undefined,
+    idleDeleteHours: undefined,
+    pruneAccounts: false,
+    deleteUnavailable: false,
+    displayMode: DEFAULT_SIMULATOR_DISPLAY_MODE,
+    displayModeFlag: undefined,
+    help: false,
+    version: false
+  };
+  for (let index = 0;index < head.length; index++) {
+    const token = head[index];
+    if (token === undefined)
+      continue;
+    if (!isManagerFlagToken(token)) {
+      state.positionals.push(token);
+      continue;
+    }
+    if (!MANAGER_FLAGS.has(token)) {
+      throw new CliUsageError(`unknown manager flag: ${token}`);
+    }
+    switch (token) {
+      case "--app": {
+        rejectDuplicate(state.appPath, token);
+        state.appPath = readRequiredValue(head, index, token);
+        index++;
+        break;
+      }
+      case "--config": {
+        rejectDuplicate(state.configPath, token);
+        state.configPath = readRequiredValue(head, index, token);
+        index++;
+        break;
+      }
+      case "--sims": {
+        rejectDuplicate(state.sims, token);
+        const value = readRequiredValue(head, index, token);
+        state.sims = parsePositiveInteger(token, value);
+        index++;
+        break;
+      }
+      case "--include-tags": {
+        state.includeTags.push(...splitTags(readRequiredValue(head, index, token)));
+        index++;
+        break;
+      }
+      case "--exclude-tags": {
+        state.excludeTags.push(...splitTags(readRequiredValue(head, index, token)));
+        index++;
+        break;
+      }
+      case "--from-run": {
+        rejectDuplicate(state.fromRunId, token);
+        state.fromRunId = readRequiredValue(head, index, token);
+        index++;
+        break;
+      }
+      case "--worktree": {
+        rejectDuplicate(state.worktreePath, token);
+        state.worktreePath = readRequiredValue(head, index, token);
+        index++;
+        break;
+      }
+      case "--idle-shutdown": {
+        rejectDuplicate(state.idleShutdownMinutes, token);
+        const value = readRequiredValue(head, index, token);
+        state.idleShutdownMinutes = parsePositiveInteger(token, value);
+        index++;
+        break;
+      }
+      case "--idle-delete": {
+        rejectDuplicate(state.idleDeleteHours, token);
+        const value = readRequiredValue(head, index, token);
+        state.idleDeleteHours = parsePositiveInteger(token, value);
+        index++;
+        break;
+      }
+      case "--keep": {
+        state.keep = true;
+        break;
+      }
+      case "--rerun-failed": {
+        state.rerunFailed = true;
+        break;
+      }
+      case "--mine": {
+        state.mine = true;
+        break;
+      }
+      case "--all": {
+        state.all = true;
+        break;
+      }
+      case "--prune-accounts": {
+        state.pruneAccounts = true;
+        break;
+      }
+      case "--delete-unavailable": {
+        state.deleteUnavailable = true;
+        break;
+      }
+      case "--headed": {
+        setDisplayMode(state, "headed", token);
+        break;
+      }
+      case "--headless": {
+        setDisplayMode(state, "headless", token);
+        break;
+      }
+      case "--help":
+      case "-h": {
+        state.help = true;
+        break;
+      }
+      case "--version":
+      case "-v": {
+        state.version = true;
+        break;
+      }
+      default: {
+        throw new CliUsageError(`unknown manager flag: ${token}`);
+      }
+    }
+  }
+  return {
+    command: state.positionals[0],
+    commandArgs: state.positionals.slice(1),
+    passthrough: state.passthrough,
+    configPath: state.configPath,
+    appPath: state.appPath,
+    sims: state.sims,
+    includeTags: state.includeTags,
+    excludeTags: state.excludeTags,
+    rerunFailed: state.rerunFailed,
+    fromRunId: state.fromRunId,
+    keep: state.keep,
+    mine: state.mine,
+    all: state.all,
+    worktreePath: state.worktreePath,
+    idleShutdownMinutes: state.idleShutdownMinutes,
+    idleDeleteHours: state.idleDeleteHours,
+    pruneAccounts: state.pruneAccounts,
+    deleteUnavailable: state.deleteUnavailable,
+    displayMode: state.displayMode,
+    help: state.help,
+    version: state.version
+  };
+}
+function setDisplayMode(state, displayMode, flag) {
+  if (state.displayModeFlag !== undefined && state.displayMode !== displayMode) {
+    throw new CliUsageError("--headed and --headless cannot be combined");
+  }
+  state.displayMode = displayMode;
+  state.displayModeFlag = flag;
+}
+
+// src/version.ts
+import { execFileSync as execFileSync7 } from "child_process";
+import { readFileSync as readFileSync8 } from "fs";
+// package.json
+var package_default = {
+  name: "maestro-manager",
+  version: "0.0.1",
+  description: "Daemonless iOS Maestro test runner with a shared simulator pool.",
+  bugs: {
+    url: "https://github.com/shipworthyai/maestro-manager/issues"
+  },
+  license: "MIT",
+  author: {
+    name: "ShipWorthy",
+    email: "maestro-manager@shipworthy.ai",
+    url: "https://shipworthy.ai/"
+  },
+  repository: {
+    type: "git",
+    url: "https://github.com/shipworthyai/maestro-manager.git"
+  },
+  bin: {
+    "maestro-manager": "./dist/cli.js"
+  },
+  files: [
+    "dist",
+    "README.md"
+  ],
+  type: "module",
+  imports: {
+    "#*": "./src/*"
+  },
+  scripts: {
+    check: "bun run typecheck && bun run lint && bun run format:check && bun run test",
+    build: "bun build ./src/cli.ts --target=bun --outfile=dist/cli.js && chmod +x dist/cli.js && bun scripts/write-build-info.mjs",
+    prepack: "bun run check && bun run build",
+    typecheck: "tsc --noEmit",
+    lint: "oxlint .",
+    format: "oxfmt .",
+    "format:check": "oxfmt --check .",
+    test: "bun test",
+    transit: "exit 0"
+  },
+  devDependencies: {
+    "@types/bun": "^1.3.14",
+    "@types/node": "26.0.0",
+    oxfmt: "0.55.0",
+    oxlint: "1.70.0",
+    typescript: "7.0.1-rc"
+  },
+  engines: {
+    bun: ">=1.3.14",
+    node: ">=24.16.0"
+  },
+  packageManager: "bun@1.3.14"
+};
+
+// src/version.ts
+var PRODUCT_DESCRIPTION = "daemonless iOS Maestro test runner with shared sim pool";
+var UNKNOWN_COMMIT = "unknown";
+var SHORT_COMMIT_PATTERN = /^[0-9a-f]{7,40}$/i;
+var VERSION_LABEL = `${package_default.version} (${resolveShortCommit()})`;
+function cliVersionLabel() {
+  return VERSION_LABEL;
+}
+function cliHelpTitle() {
+  return `maestro-manager@${VERSION_LABEL} \u2014 ${PRODUCT_DESCRIPTION}`;
+}
+function resolveShortCommit() {
+  return readBundledCommit() ?? readGitCommit() ?? UNKNOWN_COMMIT;
+}
+function readBundledCommit() {
+  try {
+    const raw = readFileSync8(new URL("./build-info.json", import.meta.url), { encoding: "utf8" });
+    return parseCommit(raw);
+  } catch (error) {
+    if (error instanceof Error)
+      return null;
+    throw error;
+  }
+}
+function readGitCommit() {
+  try {
+    const commit = execFileSync7("git", ["rev-parse", "--short=7", "HEAD"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return normalizeCommit(commit);
+  } catch (error) {
+    if (error instanceof Error)
+      return null;
+    throw error;
+  }
+}
+function parseCommit(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (!isRecord6(parsed))
+      return null;
+    const commit = parsed["commit"];
+    if (typeof commit !== "string")
+      return null;
+    return normalizeCommit(commit);
+  } catch (error) {
+    if (error instanceof SyntaxError)
+      return null;
+    throw error;
+  }
+}
+function normalizeCommit(commit) {
+  const normalized = commit.trim();
+  return SHORT_COMMIT_PATTERN.test(normalized) ? normalized : null;
+}
+function isRecord6(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/cli.ts
+var AGENT_ID = resolve3(process.cwd());
+function die(msg) {
+  process.stderr.write(`[maestro-manager] error: ${msg}
+`);
+  process.exit(1);
+}
+function errorMessage3(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function printUsage() {
+  process.stderr.write(`
+${cliHelpTitle()}
+
+Usage:
+  maestro-manager up [--app <path>] [--headed|--headless]
+  maestro-manager test [--app <path>] [--sims N] [--include-tags t1[,t2...]]
+                       [--exclude-tags t1[,t2...]] [--rerun-failed [--from-run <runId>]]
+                       [--headed|--headless] [--keep]
+                       [-- <maestro passthrough args>...]
+  maestro-manager status
+  maestro-manager ls
+  maestro-manager stop [--mine|--worktree <path>|--all]
+  maestro-manager down
+  maestro-manager clean [--idle-shutdown M] [--idle-delete H] [--prune-accounts]
+                        [--delete-unavailable]
+
+Commands:
+  up            Ensure pool.default sims exist, boot + warm them (idempotent).
+  test          Run the whole flow suite in parallel (no args = all flows).
+  status / ls   Show leases, runs index, and reconciled sim states.
+  stop          SIGTERM/SIGKILL in-scope run PIDs; keep the pool.
+                  --mine (default): only this worktree's leases
+                  --worktree <p>: leases owned by that worktree
+                  --all: all leases
+  down          stop --all + delete pool sims + clear state.
+  clean         Stateless reaper: reap orphaned runs (kill orphaned maestro + shut
+                  down the sim), reclaim stale leases, idle shutdown/delete sims.
+                  --delete-unavailable: also 'simctl delete unavailable' (GLOBAL,
+                  cross-namespace \u2014 broken-runtime device cruft; off by default).
+
+Simulator display:
+  --headless     Boot and run without opening Simulator.app (default).
+  --headed       Open Simulator.app for booted target simulators so runs are visible.
+
+Config (cwd-independent):
+  --config <path>            explicit config file (highest priority)
+  MAESTRO_MANAGER_CONFIG=... env var pointing at the config file
+  (otherwise: maestro-manager.config.json is found by walking up from cwd)
+
+`);
+}
+function printVersion() {
+  process.stdout.write(`${cliVersionLabel()}
+`);
+}
+async function main() {
+  let parsed;
+  try {
+    parsed = parseManagerArgv(process.argv.slice(2));
+  } catch (err) {
+    if (err instanceof CliUsageError)
+      die(err.message);
+    throw err;
+  }
+  if (parsed.version) {
+    printVersion();
+    process.exit(0);
+  }
+  if (parsed.command === undefined || parsed.help) {
+    printUsage();
+    process.exit(0);
+  }
+  const command = parsed.command;
+  if (command === "version") {
+    printVersion();
+    process.exit(0);
+  }
+  let config;
+  try {
+    config = loadConfig(process.cwd(), parsed.configPath);
+  } catch (err) {
+    if (err instanceof ConfigError)
+      die(err.message);
+    throw err;
+  }
+  switch (command) {
+    case "up": {
+      await runUp({ config, appPath: parsed.appPath, displayMode: parsed.displayMode });
+      break;
+    }
+    case "test": {
+      let exitCode;
+      try {
+        exitCode = await runTest({
+          config,
+          agent: AGENT_ID,
+          appPath: parsed.appPath,
+          flows: parsed.commandArgs,
+          includeTags: parsed.includeTags,
+          excludeTags: parsed.excludeTags,
+          rerunFailed: parsed.rerunFailed,
+          fromRunId: parsed.fromRunId,
+          sims: parsed.sims,
+          keep: parsed.keep,
+          passthrough: parsed.passthrough,
+          displayMode: parsed.displayMode
+        });
+      } catch (err) {
+        if (err instanceof RerunFailedSelectionError)
+          die(err.message);
+        throw err;
+      }
+      process.exit(exitCode);
+      break;
+    }
+    case "status":
+    case "ls": {
+      await runStatus({ config });
+      break;
+    }
+    case "stop": {
+      const scope = parseStopScope(parsed);
+      await runStop({ config, scope });
+      break;
+    }
+    case "down": {
+      await runDown({ config, agent: AGENT_ID });
+      break;
+    }
+    case "clean": {
+      await runClean({
+        config,
+        idleShutdownMinutes: parsed.idleShutdownMinutes,
+        idleDeleteHours: parsed.idleDeleteHours,
+        pruneAccounts: parsed.pruneAccounts,
+        deleteUnavailable: parsed.deleteUnavailable
+      });
+      break;
+    }
+    default: {
+      process.stderr.write(`[maestro-manager] unknown command: ${command}
+`);
+      printUsage();
+      process.exit(1);
+    }
+  }
+}
+function parseStopScope(parsed) {
+  if (parsed.all)
+    return { kind: "all" };
+  if (parsed.worktreePath !== undefined)
+    return { kind: "worktree", worktree: resolve3(parsed.worktreePath) };
+  return { kind: "mine", worktree: AGENT_ID };
+}
+main().catch((err) => {
+  process.stderr.write(`[maestro-manager] fatal: ${errorMessage3(err)}
+`);
+  process.exit(1);
+});