rn-iso 0.1.0 → 0.2.1

package/src/commands/stop.js

@@ -1,48 +1,80 @@
 // src/commands/stop.js
 import chalk from 'chalk';
-import { findProjectRoot } from '../project.js';
-import { getProject, setMetro } from '../config.js';
+import { resolveRegisteredProject } from '../project.js';
+import { loadConfig, getProject, setMetro } from '../config.js';
 import { killMetroByPid } from '../metro.js';
 import { getExecutor } from '../exec.js';
 
 export default function stopCommand(program) {
   program
-    .command('stop')
-    .description('Kill the Metro process for the current project')
-    .action(() => {
-      const root = findProjectRoot(process.cwd());
-      if (!root) {
-        console.error(chalk.red('Not in a React Native project.'));
+    .command('stop [target]')
+    .description('Kill Metro. With no arg, stops the current project. Pass a port (e.g. 8083), a project shortcut (label or unique basename), or an absolute path.')
+    .action((target) => {
+      // Numeric -> kill whatever's on that port.
+      if (target && /^\d+$/.test(target)) {
+        return killByPort(parseInt(target, 10));
+      }
+
+      const { found, error } = resolveRegisteredProject(target);
+      if (!found) {
+        console.error(chalk.red(error));
         process.exit(1);
       }
-      const proj = getProject(root);
+      const proj = getProject(found);
       if (!proj?.metroPort) {
-        console.log(chalk.dim('No Metro port assigned to this project.'));
+        console.log(chalk.dim(`No Metro port assigned to ${found}.`));
         return;
       }
-
-      // Try the recorded PID first (Metro spawned by `rn-iso start`).
-      // If not set or stale, look up by port (Metro spawned by the build CLI).
-      let pid = proj.metroPid;
-      if (!pid || !killMetroByPid(pid)) {
-        pid = findPidListeningOnPort(proj.metroPort);
-        if (!pid) {
-          console.log(chalk.dim(`No Metro process found on port ${proj.metroPort}.`));
-          if (proj.metroPid) setMetro(root, proj.metroPort, null);
-          return;
-        }
-        try {
-          process.kill(pid, 'SIGTERM');
-        } catch {
-          console.log(chalk.dim(`Could not kill pid ${pid}.`));
-          return;
-        }
-      }
-      setMetro(root, proj.metroPort, null);
-      console.log(chalk.green(`Killed Metro pid ${pid} on port ${proj.metroPort}`));
+      killForProject(found, proj);
     });
 }
 
+function killForProject(root, proj) {
+  const port = proj.metroPort;
+  let pid = proj.metroPid;
+  if (!pid || !killMetroByPid(pid)) {
+    pid = findPidListeningOnPort(port);
+    if (!pid) {
+      console.log(chalk.dim(`No Metro process found on port ${port}.`));
+      if (proj.metroPid) setMetro(root, port, null);
+      return;
+    }
+    try {
+      process.kill(pid, 'SIGTERM');
+    } catch {
+      console.log(chalk.dim(`Could not kill pid ${pid}.`));
+      return;
+    }
+  }
+  setMetro(root, port, null);
+  console.log(chalk.green(`Killed Metro pid ${pid} on port ${port} (${root})`));
+}
+
+function killByPort(port) {
+  const pid = findPidListeningOnPort(port);
+  if (!pid) {
+    console.log(chalk.dim(`No process listening on port ${port}.`));
+    return;
+  }
+  try {
+    process.kill(pid, 'SIGTERM');
+  } catch (e) {
+    console.log(chalk.dim(`Could not kill pid ${pid}: ${e.message}`));
+    return;
+  }
+  console.log(chalk.green(`Killed pid ${pid} on port ${port}`));
+
+  // If a project owned this port, clear its recorded pid so `status` reflects.
+  const cfg = loadConfig();
+  for (const [path, proj] of Object.entries(cfg?.projects || {})) {
+    if (proj.metroPort === port) {
+      setMetro(path, port, null);
+      console.log(chalk.dim(`Cleared metroPid for ${path}`));
+      break;
+    }
+  }
+}
+
 function findPidListeningOnPort(port) {
   const out = getExecutor().runQuiet(`lsof -nP -iTCP:${port} -sTCP:LISTEN -t`);
   if (!out) return null;

package/src/commands/unreserve.js

@@ -1,57 +1,37 @@
 // src/commands/unreserve.js
 import chalk from 'chalk';
-import { findReservations, removeReservation, clearAllReservations } from '../config.js';
+import { findProjectRoot } from '../project.js';
+import { getProject, clearDevice } from '../config.js';
 
 export default function unreserveCommand(program) {
   program
-    .command('unreserve [arg1] [arg2]')
-    .description('Release a reservation by UDID/serial or by the --label set when reserving')
-    .option('--all', 'Remove all reservations')
-    .option('--platform <platform>', 'Restrict to ios or android')
-    .action((arg1, arg2, opts) => {
-      if (opts.all) {
-        clearAllReservations();
-        console.log(chalk.green('Cleared all reservations.'));
-        return;
-      }
-
-      // Two-arg form (backward compat): `unreserve ios <id-or-label>`.
-      // Single-arg form: `unreserve <id-or-label>` (search across platforms).
-      let platform = opts.platform || null;
-      let target;
-      if (arg2 !== undefined) {
-        if (arg1 !== 'ios' && arg1 !== 'android') {
-          console.error(chalk.red(`Unknown platform: ${arg1}. Use ios or android.`));
-          process.exit(1);
-        }
-        platform = arg1;
-        target = arg2;
-      } else {
-        target = arg1;
+    .command('unreserve [platform]')
+    .description("Release the current project's lock on its sim/emulator (alias of `release` without shutdown).")
+    .action((platform) => {
+      const plat = platform || null;
+      if (plat && plat !== 'ios' && plat !== 'android') {
+        console.error(chalk.red(`Unknown platform: ${plat}. Use ios or android.`));
+        process.exit(1);
       }
 
-      if (!target) {
-        console.error(chalk.red('Usage: rn-iso unreserve <UDID|emulator-PORT|label>'));
-        console.error(chalk.dim('       rn-iso unreserve <ios|android> <UDID|emulator-PORT|label>'));
-        console.error(chalk.dim('       rn-iso unreserve --all'));
+      const root = findProjectRoot(process.cwd());
+      if (!root) {
+        console.error(chalk.red('Not in a React Native project (no package.json found).'));
         process.exit(1);
       }
-
-      const matches = findReservations(target, platform);
-      if (matches.length === 0) {
-        console.log(chalk.dim(
-          `No reservation matches "${target}"` +
-          (platform ? ` on ${platform}` : '') +
-          '.'
-        ));
+      const proj = getProject(root);
+      if (!proj) {
+        console.log(chalk.dim('No project entry to unlock.'));
         return;
       }
-      for (const m of matches) {
-        removeReservation(m.platform, m.id);
-        console.log(chalk.green(
-          `Released ${m.platform} reservation ${m.id}` +
-          (m.label ? ` (${m.label})` : '')
-        ));
+      const platforms = plat ? [plat] : ['ios', 'android'];
+      for (const p of platforms) {
+        if (proj.platforms?.[p]) {
+          clearDevice(root, p);
+          console.log(chalk.green(`Unlocked ${p} for ${root}.`));
+        } else {
+          console.log(chalk.dim(`No ${p} lock to release for ${root}.`));
+        }
       }
     });
 }

package/src/config.js

@@ -28,14 +28,8 @@ export function saveConfig(config) {
 
 export function ensureConfig() {
   const existing = loadConfig();
-  if (existing) {
-    if (!existing.reservations) {
-      existing.reservations = { ios: [], android: [] };
-      saveConfig(existing);
-    }
-    return existing;
-  }
-  const fresh = { version: 1, projects: {}, reservations: { ios: [], android: [] } };
+  if (existing) return existing;
+  const fresh = { version: 1, projects: {} };
   saveConfig(fresh);
   return fresh;
 }
@@ -108,36 +102,31 @@ export function allClaimedDevices() {
     iosUdids: [],
     androidAvds: [],
     androidConsolePorts: [],
-    // iosClaims: udid -> { source: 'project'|'reservation', label: string }
+    // iosClaims: udid -> { label, path }. androidClaims: consolePort ->
+    // { label, path, avdName }. `path` is the absolute project path so
+    // take-over flows can call clearDevice on the owning project.
     iosClaims: {},
+    androidClaims: {},
   };
   if (!cfg) return result;
   for (const [path, proj] of Object.entries(cfg.projects || {})) {
+    const label = path.split('/').pop() || path;
     const ios = proj.platforms?.ios;
     if (ios?.deviceUdid) {
       result.iosUdids.push(ios.deviceUdid);
-      result.iosClaims[ios.deviceUdid] = {
-        source: 'project',
-        label: path.split('/').pop() || path,
-      };
+      result.iosClaims[ios.deviceUdid] = { label, path };
     }
     const android = proj.platforms?.android;
     if (android?.avdName) result.androidAvds.push(android.avdName);
-    if (typeof android?.consolePort === 'number') result.androidConsolePorts.push(android.consolePort);
-  }
-  for (const r of cfg.reservations?.ios || []) {
-    if (r.udid) {
-      result.iosUdids.push(r.udid);
-      result.iosClaims[r.udid] = {
-        source: 'reservation',
-        label: r.label || 'reserved',
+    if (typeof android?.consolePort === 'number') {
+      result.androidConsolePorts.push(android.consolePort);
+      result.androidClaims[android.consolePort] = {
+        label,
+        path,
+        avdName: android.avdName,
       };
     }
   }
-  for (const r of cfg.reservations?.android || []) {
-    if (r.avdName) result.androidAvds.push(r.avdName);
-    if (typeof r.consolePort === 'number') result.androidConsolePorts.push(r.consolePort);
-  }
   return result;
 }
 
@@ -153,69 +142,3 @@ export function getSimUsage() {
   const cfg = loadConfig();
   return cfg?.simUsage || { ios: {}, android: {} };
 }
-
-export function listReservations() {
-  const cfg = loadConfig();
-  return cfg?.reservations || { ios: [], android: [] };
-}
-
-// Find reservations matching either an identifier (UDID for iOS, serial for
-// Android) or a label (the --label set via `rn-iso reserve`). Returns
-// `[{ platform, id, label }]`. Pass platform to restrict the search.
-export function findReservations(idOrLabel, platform = null) {
-  const r = listReservations();
-  const matches = [];
-  if (!platform || platform === 'ios') {
-    for (const e of r.ios || []) {
-      if (e.udid === idOrLabel || e.label === idOrLabel) {
-        matches.push({ platform: 'ios', id: e.udid, label: e.label });
-      }
-    }
-  }
-  if (!platform || platform === 'android') {
-    for (const e of r.android || []) {
-      if (e.serial === idOrLabel || e.label === idOrLabel) {
-        matches.push({ platform: 'android', id: e.serial, label: e.label });
-      }
-    }
-  }
-  return matches;
-}
-
-export function addReservation(platform, fields) {
-  if (platform !== 'ios' && platform !== 'android') {
-    throw new Error(`Unknown platform: ${platform}`);
-  }
-  const cfg = ensureConfig();
-  cfg.reservations = cfg.reservations || { ios: [], android: [] };
-  const list = cfg.reservations[platform];
-  const key = platform === 'ios' ? 'udid' : 'serial';
-  const existing = list.find(r => r[key] === fields[key]);
-  if (existing) {
-    Object.assign(existing, fields);
-  } else {
-    list.push(fields);
-  }
-  saveConfig(cfg);
-  return fields;
-}
-
-export function removeReservation(platform, identifier) {
-  if (platform !== 'ios' && platform !== 'android') {
-    throw new Error(`Unknown platform: ${platform}`);
-  }
-  const cfg = loadConfig();
-  if (!cfg?.reservations?.[platform]) return false;
-  const key = platform === 'ios' ? 'udid' : 'serial';
-  const before = cfg.reservations[platform].length;
-  cfg.reservations[platform] = cfg.reservations[platform].filter(r => r[key] !== identifier);
-  saveConfig(cfg);
-  return cfg.reservations[platform].length < before;
-}
-
-export function clearAllReservations() {
-  const cfg = loadConfig();
-  if (!cfg) return;
-  cfg.reservations = { ios: [], android: [] };
-  saveConfig(cfg);
-}

package/src/labels.js

@@ -0,0 +1,25 @@
+import prompts from 'prompts';
+
+// Decide what label to store on a project entry.
+//
+// Priority:
+//   1. --label flag (explicit override)
+//   2. existing label on the project (don't re-prompt)
+//   3. interactive prompt with the basename as default
+//   4. null (non-interactive and no prior label) -> projectShortcut falls
+//      back to the basename automatically.
+export async function resolveLabel({ root, existingProject, optsLabel }) {
+  if (optsLabel) return optsLabel;
+  if (existingProject?.label) return existingProject.label;
+  if (!process.stdin.isTTY) return null;
+
+  const basename = root.split('/').pop() || root;
+  const answer = await prompts({
+    type: 'text',
+    name: 'label',
+    message: 'Project label (shortcut for stop / release):',
+    initial: basename,
+  });
+  if (!answer.label) return null;
+  return answer.label;
+}

package/src/project.js

@@ -2,13 +2,21 @@ import { existsSync, readFileSync, readdirSync, realpathSync } from 'fs';
 import { join, dirname, resolve } from 'path';
 import { loadConfig } from './config.js';
 
-// Resolve a project from one of two forms:
-//   - undefined / null  -> walk up from cwd (current behavior)
-//   - absolute or relative path that matches a registered project key
+// A project's "shortcut": its `label` field if set, else the path basename.
+// This is the user-facing handle for `stop`, `release`, etc.
+export function projectShortcut(path, proj) {
+  if (proj?.label) return proj.label;
+  return path.split('/').pop() || path;
+}
+
+// Resolve a project from one of three forms:
+//   - undefined / null  -> walk up from cwd
+//   - absolute / relative path matching a registered project key
+//   - a shortcut (label or path basename) that uniquely identifies a project
 //
-// Basename / fuzzy matching is intentionally NOT supported -- collisions
-// across worktrees with the same dir name make it ambiguous. Use full paths
-// or the reservation label (`--label` on `rn-iso reserve`) instead.
+// Basename matching errors out on collision (multiple projects share the
+// basename) — set a `--label` on one of them via `rn-iso reserve` / `ios` /
+// `android` to disambiguate.
 //
 // Returns { found, error }.
 export function resolveRegisteredProject(arg) {
@@ -29,9 +37,19 @@ export function resolveRegisteredProject(arg) {
   if (projects[abs]) return { found: abs };
   if (projects[arg]) return { found: arg };
 
+  // Shortcut match (label or basename).
+  const matches = Object.keys(projects).filter(p => projectShortcut(p, projects[p]) === arg);
+  if (matches.length === 1) return { found: matches[0] };
+  if (matches.length > 1) {
+    return {
+      found: null,
+      error: `Multiple projects share the shortcut "${arg}": ${matches.join(', ')}. Pass the absolute path or set a unique --label.`,
+    };
+  }
+
   return {
     found: null,
-    error: `No registered project at "${arg}". Pass an absolute path; see \`rn-iso status\` for the list.`,
+    error: `No registered project matches "${arg}". See \`rn-iso status\` for the list.`,
   };
 }
 

package/src/sim/android.js

@@ -37,35 +37,48 @@ export function nextConsolePort(claimedPorts) {
 
 export function selectAndroidDevice({ existingAvd, existingConsolePort, claimedAvds, claimedConsolePorts }) {
   const avds = listAvds();
+  if (avds.length === 0) return { kind: 'noAvd' };
+
   const adbDevices = listAdbDevices();
-  const runningPorts = new Set(adbDevices.emulators.map(e => e.consolePort));
+  // Resolve which AVD each running emulator is. Emulators that don't respond
+  // to `adb emu avd name` are dropped from the running map.
+  const runningByAvd = {};
+  for (const e of adbDevices.emulators) {
+    const avdName = getAvdNameForSerial(e.serial);
+    if (avdName) runningByAvd[avdName] = e.consolePort;
+  }
+
+  const buildCandidate = (avdName) => ({
+    avdName,
+    isRunning: avdName in runningByAvd,
+    consolePort: runningByAvd[avdName] ?? null,
+  });
 
   if (existingAvd && avds.includes(existingAvd)) {
-    const port = existingConsolePort ?? nextConsolePort(claimedConsolePorts);
+    const runningPort = runningByAvd[existingAvd];
     return {
       kind: 'reuse',
       avdName: existingAvd,
-      consolePort: port,
-      isRunning: runningPorts.has(port),
+      consolePort: runningPort ?? existingConsolePort ?? nextConsolePort(claimedConsolePorts),
+      isRunning: runningPort != null,
     };
   }
 
-  if (avds.length === 0) {
-    return { kind: 'noAvd' };
-  }
-
   const claimedAvdSet = new Set(claimedAvds);
-  const candidate = avds.find(a => !claimedAvdSet.has(a));
-  if (!candidate) {
-    return { kind: 'noAvd' };
+  const all = avds.map(buildCandidate);
+  const unclaimed = all.filter(c => !claimedAvdSet.has(c.avdName));
+
+  if (unclaimed.length === 0) {
+    return { kind: 'allClaimed', candidates: sortAndroidCandidates(all) };
   }
-  const consolePort = nextConsolePort(claimedConsolePorts);
-  return {
-    kind: 'allocate',
-    avdName: candidate,
-    consolePort,
-    isRunning: runningPorts.has(consolePort),
-  };
+  return { kind: 'allocate', candidates: sortAndroidCandidates(unclaimed) };
+}
+
+export function sortAndroidCandidates(list) {
+  return [...list].sort((a, b) => {
+    if (a.isRunning !== b.isRunning) return a.isRunning ? -1 : 1;
+    return a.avdName.localeCompare(b.avdName);
+  });
 }
 
 export function bootAndroidEmulator(avdName, consolePort) {

package/src/sim/ios.js

@@ -66,8 +66,14 @@ export function selectIosDevice({ existingUdid, claimedUdids, usage = {} }) {
     }
   }
 
+  if (sims.length === 0) return { kind: 'noSims' };
+
   const unclaimed = sims.filter(s => !claimed.has(s.udid));
-  if (unclaimed.length === 0) return { kind: 'needsBoot' };
+  if (unclaimed.length === 0) {
+    // Sims exist but every one is claimed by another project or a
+    // reservation. The picker can offer to steal one; the caller decides.
+    return { kind: 'allClaimed', candidates: sortSims(sims, usage) };
+  }
 
   return { kind: 'allocate', candidates: sortSims(unclaimed, usage) };
 }

package/.claude/settings.local.json

@@ -1,7 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(git -C /Users/janicduplessis/Developer/rn-iso remote -v)"
-    ]
-  }
-}

package/CLAUDE.md

@@ -1,178 +0,0 @@
-# rn-iso — agent guide
-
-Quick orientation for AI assistants working in this repo.
-
-## What this is
-
-A Node.js CLI that gives each React Native / Expo project (or git worktree)
-its own Metro server and dedicated simulator/emulator, so multiple agents can
-work on different projects in parallel without device or port collisions.
-
-State lives in `~/.rn-iso/config.json`, keyed by absolute project path. The
-`RN_ISO_HOME` env var redirects this for tests.
-
-## Architecture conventions
-
-- **ESM only.** `"type": "module"`, no transpiler, Node 20+ directly. No
-  CommonJS, no `require()`.
-- **Single exec wrapper.** All `child_process` calls go through
-  `src/exec.js` (`getExecutor()`). Tests inject a mock via `setExecutor()`.
-  Anywhere outside `exec.js` that imports `child_process` directly is a bug.
-- **Pure parsing separate from invocation.** Functions like `parseSimctlList`,
-  `parseAdbDevices`, `selectIosDevice`, `sortSims` are pure and unit-tested;
-  the I/O wrappers around them are thin.
-- **ASCII in source files.** No em dashes, smart quotes, or check marks in
-  `src/`, `bin/`, `test/`. Markdown files (README, SKILL, this file) may use
-  them. The hooks have flagged this before.
-
-## File layout
-
-```
-bin/cli.js              # commander entry, registers each command module
-src/
-  exec.js               # mockable child_process wrapper
-  config.js             # config CRUD, reservations, sim-usage tracking
-  project.js            # project root walk, bundle-id detection (incl. native fallbacks)
-  ports.js              # Metro port allocation + reclamation
-  runner.js             # script-vs-CLI dispatch, package-manager detection (walks up for monorepos)
-  metro.js              # detached Metro spawn, PID + log lifecycle
-  sim/
-    ios.js              # simctl wrappers, sim selection, sortSims, parseRuntimeVersion
-    android.js          # adb/emulator wrappers, AVD selection
-  commands/
-    ios.js android.js   # the main user-facing commands
-    start.js stop.js logs.js
-    status.js
-    device.js           # `rn-iso device --json` -> agent-device target
-    release.js shutdown.js prune.js
-    reserve.js unreserve.js
-test/
-  *.test.js             # `node --test` (no framework)
-skill/SKILL.md          # the agent-facing skill
-```
-
-## Particularities to remember
-
-### 1. Update `skill/SKILL.md` whenever user-facing behavior changes
-
-The skill is what installed AI agents read to learn how to use the CLI. When
-you add a command, change a flag, change picker UX, or alter defaults — open
-`skill/SKILL.md` and update the relevant section in the same change. Quick
-checklist:
-
-- New command? Add it under "Other useful commands" or its own section if
-  meaty (like `reserve`).
-- New / changed flag on `ios` or `android`? Update "Core workflow" and
-  "Critical rules" if the flag matters for non-interactive agent use.
-- Behavior change (e.g., picker now does X)? Update both the
-  description and the "When things go wrong" section.
-
-The skill is shipped to users via the curl line in the README; staleness
-breaks agent guidance.
-
-### 2. Don't auto-create simulators
-
-`selectIosDevice` returns `needsBoot` only when no unclaimed sim exists at
-all. `commands/ios.js` then errors unless `--device-type` is passed. We do
-NOT prompt and create on the user's behalf — that was the original UX and
-was removed because it accumulated junk sims. The picker only chooses among
-EXISTING sims (booted or shutdown). When you change device-selection logic,
-preserve this invariant.
-
-### 3. The post-install verification step is intentionally absent
-
-Earlier versions ran `xcrun simctl install/launch` after the build CLI to
-work around a wrong-sim bug in `@expo/cli` (since fixed in 54.0.24). That
-step caused double-launches and was removed. If you find yourself wanting
-to add it back, the upstream bug is the right place to fix things —
-`patch-package` for stuck users, not workaround code in `commands/ios.js`.
-
-### 3b. `rn-iso ios` / `android` do NOT spawn Metro
-
-The build CLI (`expo run:ios` / `react-native run-ios`) starts Metro
-itself on the `--port` we pass. We used to also pre-spawn a detached
-Metro before the build, which led to two Metros on the same port.
-Removed.
-
-`rn-iso start` is still around for the explicit "I just want Metro" case
-— it spawns Metro detached and tracks the PID + log file. The build
-commands rely on the build CLI's Metro; `rn-iso stop` looks up the PID
-by port (via `lsof`) so it works regardless of who started Metro.
-
-### 4. Reservations are first-class claims
-
-`allClaimedDevices()` returns BOTH project-claimed AND reservation-claimed
-devices. If you add a new claim source (e.g., a new section in config.json),
-extend `allClaimedDevices` AND `iosClaims` so the picker greys it out with a
-useful label. Don't filter at any one call site — keep the policy in
-`config.js`.
-
-### 5. Package-manager / script detection
-
-`runner.js` prefers the project's `ios` / `android` script over a direct
-`expo run:ios` / `react-native run-ios` invocation. Reasons: respects user
-flags, picks the right CLI, works with non-standard setups (rainbow has
-`expo` in deps but uses `react-native run-ios`).
-
-`detectScriptCli` regex-matches the script body to decide flag names
-(`--device <UDID>` for Expo, `--udid <UDID>` for RN). If you ever need a
-new flag, update both the script-path branch and the direct fallback.
-
-`detectPackageManager` walks up from the project root looking for a
-lockfile (monorepo support). Don't single-directory-check.
-
-### 6. `RN_ISO_HOME` is the test redirect
-
-All config + log paths derive from `getConfigDir()`, which respects
-`RN_ISO_HOME`. Every config-touching test does:
-
-```js
-beforeEach(() => {
-  tmpHome = mkdtempSync(join(tmpdir(), 'rn-iso-test-'));
-  process.env.RN_ISO_HOME = tmpHome;
-});
-afterEach(() => {
-  rmSync(tmpHome, { recursive: true, force: true });
-  delete process.env.RN_ISO_HOME;
-});
-```
-
-If you add new state-touching code, follow this pattern.
-
-### 7. `findProjectRoot` uses `realpath`
-
-So symlinked worktrees collapse to the same canonical key as the
-non-symlinked path. Don't add code that compares paths without
-canonicalizing first.
-
-## Local development
-
-```bash
-npm install         # one-time
-npm test            # node --test test/*.test.js
-npm link            # symlink rn-iso onto your PATH for live testing
-```
-
-After `npm link`, edits to `src/` are picked up immediately by the linked
-`rn-iso` command.
-
-## Commit conventions
-
-- GPG signing is enabled globally — commits sign automatically. Don't pass
-  `--no-gpg-sign`. If you need to re-sign an existing commit (e.g.,
-  someone forgot signing), `git commit --amend --no-edit -S` works.
-- Conventional-style prefixes are used (`feat:`, `fix:`, `docs:`,
-  `chore:`, `revert:`). Keep titles under ~70 chars; details in the body.
-- One commit per logical change. The post-install removal and the
-  script-based runner came in as separate commits even though they shipped
-  in the same session.
-
-## Things explicitly out of scope (for now)
-
-- Locking / mutex around device usage. The whole premise is dedicated sims.
-- Auto-shutdown of sims after N hours of inactivity.
-- Cross-platform support beyond macOS (iOS) + macOS/Linux (Android).
-- Multi-app projects (one repo, multiple Expo apps via `--variant`).
-- A daemon or TUI dashboard.
-
-If a request edges into these, raise it instead of building it.