stim 1.14.0 → 1.16.0

package/dist/{status-BsPAnfOI.mjs → status-Cs7VLg9D.mjs}

@@ -1,32 +1,89 @@
-import { I as volumeRootFor, U as projectDeviceSlots, _ as loadConfig$1, d as getConfigDir, z as deviceSlotKey } from "./config-lvc7d3C2.mjs";
-import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
-import { a as parseNdjsonLine } from "./ndjson-CDY9IkVC.mjs";
-import { M as workspaceLogsDir, c as resolveProjectMetro, h as readWorkspaceState$1, i as listeningPidsByPort, j as workspaceLogErrorIndex, o as processCwd, r as listeningPids, s as processCwds, u as isMetroRunning } from "./metro-CcEo8Fl8.mjs";
-import { c as gitCommonDirOnDisk, p as linkedWorktreesOnDisk, s as gitCommonDir, y as repoRoot } from "./worktree-BVrHsYZG.mjs";
-import { l as projectShortcut, o as findServerWorkspace, r as detectIsExpo } from "./project-CWlvEaeN.mjs";
-import { f as readWorkspaceLaunches, u as readRemoteSession } from "./state-DHqvsbqC.mjs";
-import { i as formatDuration } from "./command-output-DVcpw6eE.mjs";
-import { i as listLeaseFiles } from "./device-lease-5c3WrVRm.mjs";
-import { n as createActivityReader, r as createDeviceProcessTables } from "./activity-CYVDcrt3.mjs";
-import { P as ownedAvdDeviceProfile, R as ownedAvdSerialResolver, ct as parkedMaxSetting, lt as readParked, rt as POOL_SETTING_REMEDY, u as androidToolPath } from "./android-d6rGq1pA.mjs";
-import { n as describeMetroLastStop, o as metroLastStop, u as resolveSupervisorTarget } from "./stop-cause-hjGBOZTG.mjs";
-import { a as readWebRecord, l as webFacts } from "./state-Dk9RVXI7.mjs";
-import { _ as parseSimctlList, u as listAllIosSimsAsync } from "./ios-BwDPrnYQ.mjs";
-import { a as buildStatusLine, i as buildReport, r as activeBuildState, s as parseActiveBuild, t as ACTIVE_BUILD_KEY } from "./build-progress-DxKpwnaS.mjs";
-import { T as readEasSessionLedger$1, w as easMachineStateRoot$1 } from "./device-remote-D87zEzaq.mjs";
-import { _ as withWebFacts, a as deviceLeaseStates, d as poolLine, f as remoteDeviceLine, g as unprovisionedWorktrees, h as tightVolumes, i as deviceLeaseLines, l as gitSummaryText, m as statusActivity, n as activityLabel, o as diskLine, p as remoteDeviceState, r as capacity, s as environmentState, u as parseDfFree } from "./status-BgAuxESg.mjs";
-import { a as statsProjectKey, r as readStats } from "./stats-CX1Z8Tca.mjs";
-import { n as mergeState } from "./merge-state-ytFQCeh4.mjs";
-import { i as readSupervisorState } from "./stop-BzreOWJp.mjs";
-import { mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, watch, writeFileSync } from "node:fs";
-import { closeSync as closeSync$1, existsSync as existsSync$1, fstatSync as fstatSync$1, openSync as openSync$1, readFileSync as readFileSync$1, readSync as readSync$1, renameSync as renameSync$1, rmSync as rmSync$1, writeFileSync as writeFileSync$1 } from "fs";
-import { basename, dirname, join } from "path";
-import { rotatedLogPath } from "@stim-cli/core";
-import { ERROR_SOURCES, MACHINE_OWNER_KINDS, gitMergeCacheDir, logFiles, queryLogs, readBuildHistory, readIdleStop, readLastBuilds, recordMatches, withStateReadCache } from "@stim-cli/core/state";
-import { join as join$1, posix, resolve as resolve$1 } from "node:path";
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+import { B as parseDeviceSlotKey, F as volumeRootFor, H as projectDeviceSlots, R as deviceSlotKey, _ as loadConfig$1, d as getConfigDir, j as formatBytes } from "./config-D0DbpZtM.mjs";
+import { t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
+import { a as formatElapsed, i as formatDuration, r as clockTime, u as plural } from "./command-output-DnJMdEY-.mjs";
+import { P as resolveSettings, at as gitCommonDirOnDisk, gt as repoRoot, it as gitCommonDir, ut as linkedWorktreesOnDisk } from "./settings-oTSkkNrM.mjs";
+import { i as detectPlatforms, r as detectIsExpo, s as findServerWorkspace, u as projectShortcut } from "./project-Du91Ilvc.mjs";
+import { a as listeningPidsByPort, c as processCwds, d as isMetroRunning, i as listeningPids, l as resolveProjectMetro, o as pidExists, s as processCwd } from "./metro-BeK1ZPz1.mjs";
+import { b as workspaceLogErrorIndex, r as readWorkspaceState$1, x as workspaceLogsDir$1 } from "./workspace-state-B8-aJ1_5.mjs";
+import { a as readWebPage, o as readWebRecord, u as webFacts } from "./state-C1jB7Q8q.mjs";
+import { _ as statusActivity, a as capacity, b as withWebFacts, c as diskLine, d as gitSummaryText, f as metroReverseTargets, g as remoteDeviceState, h as remoteDeviceLine, i as applyMachineMemory, l as environmentState, m as poolLine, n as activityLabel, o as deviceLeaseLines, p as parseDfFree, r as addReverseMissingIssue, s as deviceLeaseStates, v as tightVolumes, y as unprovisionedWorktrees } from "./status-BuvBFeII.mjs";
+import { J as attributeMachineUsage, Y as readFootprints, a as machineNumber } from "./budget-DjrURfQn.mjs";
+import { d as readWebActivity, f as tailLines, i as createDeviceProcessTables, r as createActivityReader } from "./activity-BxwdD81S.mjs";
+import { i as listLeaseFiles, r as leaseIsExpired, s as parseWorkspaceLeases } from "./device-lease-D-hLqx1b.mjs";
+import { c as readMetroTunnel, f as readWorkspaceLaunches, u as readRemoteSession } from "./state-DcW6vOd_.mjs";
+import { S as statsProjectKey$1, b as readStats$1, c as ACTIVE_BUILD_KEY, d as buildReport, f as buildStatusLine, m as parseActiveBuild, u as activeBuildState } from "./idle-DYVymG92.mjs";
+import { F as ownedAvdDeviceProfile, O as listAdbDevices, d as androidToolPath, ft as parkedMaxSetting, ot as POOL_SETTING_REMEDY, pt as readParked, z as ownedAvdSerialResolver } from "./android-B_NumVyQ.mjs";
+import { d as listAllIosSimsAsync, v as parseSimctlList } from "./ios-BaInn3sW.mjs";
+import { t as resolveSupervisorTarget } from "./ownership-hCkPzGmr.mjs";
+import { a as parseNdjsonLine } from "./ndjson-PclOIwVY.mjs";
+import { n as describeMetroLastStop, o as metroLastStop } from "./stop-cause-CidxIqup.mjs";
+import { l as probeHostedSession } from "./hosted-client-a-WmqE2L.mjs";
+import { m as hasMetroReverse } from "./app-install-CKWdbXIX.mjs";
+import "./hosted-macos-BSZyIb3y.mjs";
+import { m as readEasSessionLedger$1, p as easMachineStateRoot$1 } from "./device-remote-D5WVWqOq.mjs";
+import { d as readIosDevices, s as isReachable } from "./ios-device-FfCN_C8p.mjs";
+import { n as maintenanceLines, r as maintenanceStatus } from "./status-DlKvVJBE.mjs";
+import { i as createStatusMeasurer, n as workspacePhase, r as applyStatusMeasures, s as mergeState } from "./warm-progress-CpGv3Wb6.mjs";
+import { r as workspaceRecordingEnabled } from "./recordings-BIXOzVnr.mjs";
+import { t as watchStdoutReader } from "./stdout-reader-C8yjre1x.mjs";
+import { t as triggerMaintenance } from "./trigger-Bemu8ytw.mjs";
+import { i as readSupervisorState } from "./stop-Bffozsac.mjs";
 import { createHash, randomUUID } from "node:crypto";
+import { mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, watch, writeFileSync } from "node:fs";
+import { join, posix, resolve } from "node:path";
+import { closeSync as closeSync$1, existsSync as existsSync$1, fstatSync as fstatSync$1, openSync as openSync$1, readFileSync as readFileSync$1, readSync as readSync$1, renameSync as renameSync$1, rmSync as rmSync$1, statSync as statSync$1, writeFileSync as writeFileSync$1 } from "fs";
 import { homedir, totalmem } from "os";
+import { basename as basename$1, dirname as dirname$1, join as join$1 } from "path";
+import { rotatedLogPath } from "@stim-cli/core";
+import { ERROR_SOURCES, archiveRoot, archivedUsage, bundleMarkerPlatform, countErrorEntries, gitMergeCacheDir, hostedIosPlacements, hostedIosRecords, hostedIosStatus, linkReplacedArchives, logFiles, macosAppState, parseHostedIosPlacement, queryLogs, readArchives, readBuildDetail, readBuildHistory, readDeviceIdleShutdowns, readIdleStop, readLastBuilds, readMacosRecord, recordMatches, sortByTs, unreadableHostedIos, withDerivedFacts, withGitChip, withStateReadCache } from "@stim-cli/core/state";
 import chalk from "chalk";
+//#region src/device-host/hosted-ios-status.ts
+function applyHostedIosProbe(placement, probe, slot = "default") {
+	const rerun = `stim ios --remote ${placement.machine}${slot === "default" ? "" : ` --slot ${slot}`}`;
+	const state = probe.state === "ready" ? "ready" : probe.state === "stopped" ? "stopped" : "unverified";
+	return {
+		ios: {
+			host: {
+				...hostedIosStatus(placement),
+				state
+			},
+			name: placement.device?.name ?? null,
+			udid: "",
+			owned: false,
+			state
+		},
+		...probe.state === "ready" ? {} : { warning: probe.state === "stopped" ? `The iOS session on ${placement.machine} stopped or no longer exists. Run ${rerun} to launch it again, or stim stop to clear the placement.` : `${placement.machine} could not confirm its iOS session${probe.state === "unknown" ? probe.notice ? `: ${probe.notice}` : "" : `: ${probe.reason.replace(/\.+$/, "")}`}. The placement stays recorded; run stim stop when the host answers.` }
+	};
+}
+async function readHostedIosStatus(placements) {
+	return Object.fromEntries(await Promise.all(Object.entries(placements).map(async ([slot, placement]) => [slot, applyHostedIosProbe(placement, await probeHostedSession(placement), slot)])));
+}
+//#endregion
+//#region src/device-host/hosted-macos-status.ts
+function applyHostedMacosProbe(record, probe) {
+	if (!record.host || probe.state === "ready") return { record };
+	const { machine, session } = record.host;
+	if (probe.state === "stopped") return {
+		record: {
+			...record,
+			hostLaunched: false
+		},
+		warning: `The macOS app on ${machine} is no longer running (the host reports session ${session} stopped or no longer holds it, for example after a stim-server restart there). Run stim macos --remote ${machine} to launch it again, or stim stop to clear the placement.`
+	};
+	return {
+		record: {
+			...record,
+			hostLaunched: "unverified"
+		},
+		warning: probe.state === "unknown" ? `${probe.notice ?? `The host cannot confirm session ${session} on ${machine}.`} Run stim stop to reconcile it.` : `${machine} could not be checked (${probe.reason}), so the macOS app there is unverified. The placement stays recorded; run stim stop when the host answers.`
+	};
+}
+async function readHostedMacosStatus(record, options) {
+	if (!record?.host || record.supervisor || !record.hostLaunched) return { record };
+	return applyHostedMacosProbe(record, await probeHostedSession(record.host, options));
+}
+//#endregion
 //#region src/status-watch.ts
 const WATCH_FALLBACK_MS = 3e4;
 const WATCH_LIGHT_INTERVAL_MS = 15e3;
@@ -88,17 +145,23 @@ function createRefreshScheduler({ debounceMs, lightIntervalMs = 0, run }) {
 	};
 }
 /**
-* Which refresh a change to `name` in a watched `$STIM_HOME` directory needs: `light` for a log append, which can
-* change only the log-derived fields, `full` for anything else that can change the payload, null for none. A null
-* name means the platform did not report one.
+* Which refresh a change to `name` in a watched `$STIM_HOME` directory needs: `light` for a log append or a running
+* build's detail, which can change only the log-derived fields, `full` for anything else that can change the payload,
+* null for none. A null name means the platform did not report one.
 */
 function statusChange(dir, name) {
+	if (dir === "archive" && (name?.startsWith(".incoming-") || name?.startsWith(".removing-") || name?.startsWith(".lock"))) return null;
 	if (name?.includes(".lock")) return null;
 	if (dir === "logs") return "light";
 	if (name === null) return "full";
 	switch (dir) {
-		case "home": return name.startsWith("config.json") || name === "workspaces" || name === "device-locks" ? "full" : null;
-		case "workspace": return name.startsWith("state.json") || name === "logs" ? "full" : null;
+		case "home":
+			if (name === "maintenance") return "light";
+			return name.startsWith("config.json") || name === "archive" || name === "workspaces" || name === "device-locks" ? "full" : null;
+		case "workspace":
+			if (name.startsWith("build-detail.json")) return "light";
+			return name.startsWith("state.json") || name.startsWith("ended-agents.json") || name === "logs" ? "full" : null;
+		case "maintenance": return name === "state.json" ? "light" : null;
 		case "eas": return name.startsWith("sessions.json") ? "full" : null;
 		default: return "full";
 	}
@@ -122,18 +185,20 @@ function watchStatusSources({ home, onChange, platform = process.platform, simct
 	const desiredDirs = () => {
 		const dirs = /* @__PURE__ */ new Map([
 			[home, "home"],
-			[join$1(home, "workspaces"), "workspaces"],
-			[join$1(home, "device-locks"), "leases"],
+			[join(home, "archive"), "archive"],
+			[join(home, "workspaces"), "workspaces"],
+			[join(home, "maintenance"), "maintenance"],
+			[join(home, "device-locks"), "leases"],
 			[easMachineStateRoot$1(), "eas"]
 		]);
 		let names = [];
 		try {
-			names = readdirSync(join$1(home, "workspaces"));
+			names = readdirSync(join(home, "workspaces"));
 		} catch {}
 		for (const name of names) {
-			const dir = join$1(home, "workspaces", name);
+			const dir = join(home, "workspaces", name);
 			dirs.set(dir, "workspace");
-			dirs.set(join$1(dir, "logs"), "logs");
+			dirs.set(join(dir, "logs"), "logs");
 		}
 		return dirs;
 	};
@@ -266,7 +331,7 @@ function trackAdbDevices(onChange) {
 }
 //#endregion
 //#region src/diagnostics/error-index.ts
-const INDEX_VERSION = 3;
+const INDEX_VERSION = 7;
 const HEAD_BYTES = 1024;
 const TAIL_BYTES = 256;
 const CHUNK_BYTES = 4194304;
@@ -282,7 +347,7 @@ const ERROR_CRITERIA = {
 	includeAppDeviceErrors: true
 };
 /**
-* The number of records `queryLogs({ dir, errorsOnly: true })` returns, without parsing every
+* The number of rows the apps list for `queryLogs({ dir, errorsOnly: true })`, one per failure, without parsing every
 * line on every call. `indexFile` keeps, per log file generation, the markers and error records
 * already read and the byte offset they were read through; a later call reads only what was
 * appended since. The index is a cache: losing it or a concurrent writer only costs a rescan.
@@ -292,7 +357,7 @@ function countErrorsSinceMarker(dir, indexFile) {
 	const files = {};
 	let changed = false;
 	for (const name of logFiles(dir)) {
-		const current = join(dir, name);
+		const current = join$1(dir, name);
 		for (const path of [rotatedLogPath(current), current]) {
 			const result = summarize(path, previous.files);
 			if (!result) continue;
@@ -306,10 +371,10 @@ function countErrorsSinceMarker(dir, indexFile) {
 	});
 	const records = [];
 	for (const summary of Object.values(files)) records.push(...Object.values(summary.markers), ...summary.errors);
-	return queryLogs({
+	return countErrorEntries(sortByTs(queryLogs({
 		records,
 		errorsOnly: true
-	}).length;
+	})));
 }
 function summarize(path, known) {
 	let fd;
@@ -401,11 +466,17 @@ function collect(record, markers, errors) {
 		const metro = record.src === "metro";
 		const web = !metro && record.platform === "web";
 		const slot = record.slot ?? "default";
-		const key = metro ? "metro" : web ? "web" : JSON.stringify(["launch", slot]);
+		const platform = metro ? bundleMarkerPlatform(record) : record.platform ?? null;
+		const key = web ? "web" : JSON.stringify([
+			metro ? "metro" : "launch",
+			slot,
+			platform
+		]);
 		if ((markers[key]?.ts ?? -Infinity) < ts) markers[key] = metro ? {
 			src: "metro",
 			marker: true,
-			ts
+			ts,
+			...platform === null ? {} : { platform }
 		} : web ? {
 			platform: "web",
 			marker: true,
@@ -413,16 +484,20 @@ function collect(record, markers, errors) {
 		} : {
 			marker: true,
 			ts,
-			slot
+			slot,
+			...platform === null ? {} : { platform }
 		};
 	}
 	if (recordMatches(record, ERROR_CRITERIA)) errors.push({
 		src: record.src,
 		level: record.level,
 		event: record.event,
-		platform: record.platform,
+		platform: record.src === "metro" && record.marker === true ? bundleMarkerPlatform(record) : record.platform,
 		ts: ts ?? void 0,
-		slot: record.slot
+		slot: record.slot,
+		raw: record.raw,
+		marker: record.marker,
+		msg: record.marker === true ? record.msg : void 0
 	});
 }
 function readIndex(file) {
@@ -513,7 +588,7 @@ async function defaultBranchOf(repository) {
 	};
 }
 function mergeCacheFile(path) {
-	return join$1(gitMergeCacheDir(), `${createHash("sha256").update(path).digest("hex").slice(0, 32)}.json`);
+	return join(gitMergeCacheDir(), `${createHash("sha256").update(path).digest("hex").slice(0, 32)}.json`);
 }
 function readMergeCache(path) {
 	try {
@@ -587,14 +662,14 @@ const mergeTimeouts = /* @__PURE__ */ new Map();
 const recent = /* @__PURE__ */ new Map();
 function gitDirsOf(worktree) {
 	try {
-		const dotGit = join$1(worktree, ".git");
+		const dotGit = join(worktree, ".git");
 		const pointer = statSync(dotGit).isDirectory() ? null : /^gitdir: (.+)$/m.exec(readFileSync(dotGit, "utf-8"))?.[1]?.trim();
-		const gitDir = pointer ? resolve$1(worktree, pointer) : pointer === null ? dotGit : null;
+		const gitDir = pointer ? resolve(worktree, pointer) : pointer === null ? dotGit : null;
 		if (!gitDir) return null;
 		try {
 			return {
 				gitDir,
-				commonDir: resolve$1(gitDir, readFileSync(join$1(gitDir, "commondir"), "utf-8").trim())
+				commonDir: resolve(gitDir, readFileSync(join(gitDir, "commondir"), "utf-8").trim())
 			};
 		} catch {
 			return {
@@ -623,21 +698,21 @@ function fileStamp(path) {
 function gitFilesStamp(worktree, refs) {
 	const dirs = gitDirsOf(worktree.path);
 	if (!dirs) return {
-		stamp: fileStamp(join$1(worktree.path, ".git")),
+		stamp: fileStamp(join(worktree.path, ".git")),
 		missing: true
 	};
 	const { gitDir, commonDir } = dirs;
 	return {
 		stamp: [
-			join$1(gitDir, "index"),
-			join$1(gitDir, "HEAD"),
-			join$1(gitDir, "logs", "HEAD"),
-			join$1(commonDir, "packed-refs"),
-			join$1(commonDir, "FETCH_HEAD"),
-			join$1(commonDir, "refs", "remotes", "origin", "HEAD"),
-			...refs.target ? [join$1(commonDir, refs.target)] : [],
-			...worktree.branch ? [join$1(commonDir, "refs", "heads", worktree.branch)] : [],
-			...refs.upstream ? [join$1(commonDir, "refs", "remotes", refs.upstream), join$1(commonDir, "refs", "heads", refs.upstream)] : []
+			join(gitDir, "index"),
+			join(gitDir, "HEAD"),
+			join(gitDir, "logs", "HEAD"),
+			join(commonDir, "packed-refs"),
+			join(commonDir, "FETCH_HEAD"),
+			join(commonDir, "refs", "remotes", "origin", "HEAD"),
+			...refs.target ? [join(commonDir, refs.target)] : [],
+			...worktree.branch ? [join(commonDir, "refs", "heads", worktree.branch)] : [],
+			...refs.upstream ? [join(commonDir, "refs", "remotes", refs.upstream), join(commonDir, "refs", "heads", refs.upstream)] : []
 		].map(fileStamp).join(" "),
 		missing: false
 	};
@@ -753,7 +828,7 @@ function plistBundleId(appPath) {
 		"raw",
 		"-o",
 		"-",
-		join$1(appPath, "Info.plist")
+		join(appPath, "Info.plist")
 	], { timeoutMs: 2e3 })?.trim() || null;
 	if (id) bundleIdsByApp.set(appPath, id);
 	return id;
@@ -777,196 +852,178 @@ function createAppProcessReader(tables, bundleIdOf = plistBundleId) {
 	};
 }
 //#endregion
-//#region src/machine-usage.ts
-const SHARED = [
-	{
-		name: "CoreSimulator services",
-		pattern: /\/CoreSimulator\.framework\/|\/Simulator\.app\/Contents\/MacOS\//
-	},
-	{
-		name: "adb server",
-		pattern: /(^|\/)adb\s.*\bfork-server\b/
-	},
-	{
-		name: "Android emulator services",
-		pattern: /\/emulator\/netsimd(\s|$)/
-	},
-	{
-		name: "Gradle daemon",
-		pattern: /\borg\.gradle\.launcher\.daemon\.bootstrap\.GradleDaemon\b/
-	},
-	{
-		name: "Kotlin daemon",
-		pattern: /\bKotlinCompileDaemon\b/
-	},
-	{
-		name: "Watchman",
-		pattern: /(^|\/)watchman(\s|$)/
+//#region src/metro-bundle.ts
+const IN_FLIGHT_MAX_MS = 6e5;
+const RESTART_EVENTS = /* @__PURE__ */ new Set(["supervisor_started", "server_started"]);
+const BUNDLE_EVENT = /^bundle_(?:response|prefetch)_(started|progress|finished|failed)$/;
+function parseRecord(line) {
+	if (!line.includes("\"bundle_") && !line.includes("_started\"")) return null;
+	try {
+		const value = JSON.parse(line);
+		return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+	} catch {
+		return null;
 	}
-];
-const SERVER = /(^|[\s/])stim-server(\.mjs)?(\s|$)/;
-const LAUNCHD_SIM = /^launchd_sim\s.*\/Devices\/([^/\s]+)\//;
-const MAX_DEPTH = 64;
-const EMULATOR = /(?:^|\/)(?:qemu-system-[^\s/]+|emulator)(?:\s.*)?\s(?:-avd\s+|@)(\S+)/;
-function emulatorAvd(command) {
-	return EMULATOR.exec(command)?.[1] ?? null;
-}
-function workspaceOwner(kind, env, name, id) {
-	return {
-		kind,
-		name,
-		workspace: env.path,
-		id,
-		owned: true
-	};
 }
-function rank(owner) {
-	return MACHINE_OWNER_KINDS.indexOf(owner.kind);
+function platformOf(value) {
+	return value === "ios" || value === "android" ? value : null;
 }
 /**
-* Attributes every process in `processes` to at most one owner: the owner of its nearest ancestor (itself included)
-* that is a root. Roots are each booted simulator's `launchd_sim`, each emulator launcher and qemu process, and each
-* workspace's verified supervisor and Metro, running build and Chrome. Only a process under none of those falls back
-* to stim-server or a machine-wide service in `SHARED`, so a `simctl` a workspace's log collector runs stays with the
-* workspace. A process with no root ancestor is left out.
+* The bundle state of a workspace's Metro from the tail of its `metro.ndjson`: the records Stim's middleware writes
+* for each native bundle request, an app's (`bundle_response_*`) or Stim's own prefetch (`bundle_prefetch_*`),
+* matched by `requestId`. A request counts as in flight only while
+* Metro runs, when it started under the current dev server and less than 10 minutes ago, since a dev server that
+* died mid-request never records its end. Null when the tail holds no bundle request.
 */
-function attributeMachineUsage({ processes, environments, roots, simNames }) {
-	const owners = /* @__PURE__ */ new Map();
-	const rootOf = /* @__PURE__ */ new Map();
-	const fallbackOf = /* @__PURE__ */ new Map();
-	const claim = (pid, key, owner, into = rootOf) => {
-		if (!owners.has(key)) owners.set(key, owner);
-		into.set(pid, key);
-	};
-	const sims = /* @__PURE__ */ new Map();
-	const emulators = /* @__PURE__ */ new Map();
-	for (const env of environments) for (const device of [{
-		slot: "default",
-		ios: env.ios,
-		android: env.android
-	}, ...env.slots ?? []]) {
-		const slot = device.slot === "default" ? {} : { slot: device.slot };
-		if (device.ios?.state === "Booted") sims.set(device.ios.udid.toUpperCase(), {
-			kind: "simulator",
-			name: device.ios.name ?? device.ios.udid,
-			workspace: env.path,
-			...slot,
-			id: device.ios.udid,
-			owned: device.ios.owned
-		});
-		if (device.android?.name && !device.android.physical && device.android.serial) emulators.set(device.android.name, {
-			kind: "emulator",
-			name: device.android.name,
-			workspace: env.path,
-			...slot,
-			id: device.android.name,
-			owned: device.android.owned
-		});
-	}
-	for (const p of processes) {
-		const shared = SHARED.find(({ pattern }) => pattern.test(p.command));
-		if (shared) {
-			const owner = {
-				kind: "shared",
-				name: shared.name,
-				workspace: null,
-				id: null,
-				owned: false
-			};
-			claim(p.pid, `shared:${shared.name}`, owner, fallbackOf);
+function metroBundleState(lines, { running, now }) {
+	let open = /* @__PURE__ */ new Map();
+	let last;
+	let seen = false;
+	for (const line of lines) {
+		const record = parseRecord(line);
+		if (!record) continue;
+		const { event, requestId, ts } = record;
+		if (typeof event !== "string") continue;
+		if (RESTART_EVENTS.has(event)) {
+			open = /* @__PURE__ */ new Map();
 			continue;
 		}
-		if (SERVER.test(p.command)) {
-			claim(p.pid, "server", {
-				kind: "server",
-				name: "stim-server",
-				workspace: null,
-				id: null,
-				owned: false
-			}, fallbackOf);
-			continue;
-		}
-		const udid = LAUNCHD_SIM.exec(p.command)?.[1]?.toUpperCase();
-		if (udid) {
-			const owner = sims.get(udid) ?? {
-				kind: "simulator",
-				name: simNames[udid] ?? udid,
-				workspace: null,
-				id: udid,
-				owned: false
-			};
-			claim(p.pid, `simulator:${udid}`, owner);
-			continue;
-		}
-		const avd = emulatorAvd(p.command);
-		if (avd) {
-			const owner = emulators.get(avd) ?? {
-				kind: "emulator",
-				name: avd,
-				workspace: null,
-				id: avd,
-				owned: false
+		const platform = platformOf(record.platform);
+		const stage = BUNDLE_EVENT.exec(event)?.[1];
+		if (!stage || typeof requestId !== "string" || typeof ts !== "number" || !platform) continue;
+		seen = true;
+		if (stage === "started") open.set(requestId, {
+			platform,
+			startedAt: ts
+		});
+		else if (stage === "progress") {
+			const request = open.get(requestId);
+			const percent = record.percent;
+			if (request && typeof percent === "number" && percent >= 0 && percent <= 100) request.percent = percent;
+		} else {
+			const request = open.get(requestId);
+			open.delete(requestId);
+			if (!request) continue;
+			last = {
+				platform,
+				status: stage === "finished" ? "ok" : "failed",
+				durationMs: Math.max(0, ts - request.startedAt),
+				finishedAt: new Date(ts).toISOString()
 			};
-			claim(p.pid, `emulator:${avd}`, owner);
-		}
-	}
-	const present = new Set(processes.map((p) => p.pid));
-	const byPath = new Map(environments.map((env) => [env.path, env]));
-	for (const root of roots) {
-		const env = byPath.get(root.path);
-		if (!env) continue;
-		const metroPids = [root.supervisorPid, env.metro?.running ? env.metro.pid : null];
-		for (const pid of metroPids) if (pid && present.has(pid)) {
-			const port = env.metro?.port ?? null;
-			claim(pid, `metro:${env.path}`, workspaceOwner("metro", env, port ? `Metro :${port}` : "Metro", port ? String(port) : null));
-		}
-		if (root.build && present.has(root.build.pid)) {
-			const label = root.build.platform === "ios" ? "iOS build" : "Android build";
-			claim(root.build.pid, `build:${env.path}`, workspaceOwner("build", env, label, root.build.platform));
 		}
-		for (const pid of root.browserPids) if (present.has(pid)) claim(pid, `browser:${env.path}`, workspaceOwner("browser", env, "Chrome", null));
 	}
-	const parentOf = new Map(processes.map((p) => [p.pid, p.ppid]));
-	const totals = /* @__PURE__ */ new Map();
-	for (const p of processes) {
-		let pid = p.pid;
-		let key;
-		let fallback;
-		for (let depth = 0; pid !== void 0 && pid > 1 && depth < MAX_DEPTH; depth++) {
-			key = rootOf.get(pid);
-			if (key) break;
-			fallback ??= fallbackOf.get(pid);
-			pid = parentOf.get(pid);
-		}
-		key ??= fallback;
-		if (!key) continue;
-		const total = totals.get(key) ?? {
-			rssKb: 0,
-			cpu: 0,
-			processes: 0
-		};
-		total.rssKb += p.rssKb;
-		total.cpu += p.cpuPercent;
-		total.processes += 1;
-		totals.set(key, total);
-	}
-	const list = [];
-	for (const [key, owner] of owners) {
-		const total = totals.get(key);
-		if (total) list.push({
-			...owner,
-			cpuPercent: Math.round(total.cpu),
-			residentMb: Math.round(total.rssKb / 1024),
-			processes: total.processes
+	if (!seen) return null;
+	const active = running ? [...open.values()].filter((request) => now - request.startedAt < IN_FLIGHT_MAX_MS).toSorted((a, b) => b.startedAt - a.startedAt)[0] : void 0;
+	return {
+		bundling: Boolean(active),
+		...active ? {
+			platform: active.platform,
+			startedAt: new Date(active.startedAt).toISOString(),
+			...active.percent === void 0 ? {} : { percent: active.percent }
+		} : {},
+		...last ? { last } : {}
+	};
+}
+//#endregion
+//#region src/physical-devices.ts
+const EMULATOR_SERIAL = /^emulator-\d+$/;
+/**
+* The physical devices a workspace holds: each lease its state records whose file still carries the same token,
+* names this workspace as holder, and has not expired. A lease on a simulator (a UDID in `simulatorUdids`) or an
+* emulator (an `emulator-<port>` serial), which `device lock` also takes, is not a physical device. `read` is
+* called once per device.
+*/
+function physicalDeviceStates(entries, held, { root, now, simulatorUdids, read }) {
+	const out = [];
+	for (const [key, record] of Object.entries(held)) {
+		const parsed = parseDeviceSlotKey(key);
+		const lease = entries.find((entry) => entry.lease?.token === record.token)?.lease;
+		if (!parsed || !lease || lease.platform !== parsed.platform || lease.id !== record.id) continue;
+		if (lease.holder !== root || leaseIsExpired(lease, now)) continue;
+		if (parsed.platform === "ios" ? simulatorUdids.has(lease.id.toUpperCase()) : EMULATOR_SERIAL.test(lease.id)) continue;
+		const reading = read(parsed.platform, lease.id);
+		out.push({
+			platform: parsed.platform,
+			slot: parsed.slot,
+			id: lease.id,
+			name: reading.name ?? lease.deviceName,
+			model: reading.model ?? (parsed.platform === "android" && lease.deviceName !== lease.id ? lease.deviceName : null),
+			owned: false,
+			physical: true,
+			connection: reading.connection,
+			lease: {
+				holder: lease.holder,
+				kind: record.kind,
+				grantedAt: lease.grantedAt,
+				expiresAt: lease.expiresAt
+			}
 		});
 	}
-	list.sort((x, y) => rank(x) - rank(y) || (x.workspace ?? "~").localeCompare(y.workspace ?? "~") || x.name.localeCompare(y.name));
-	return { owners: list };
+	return out;
+}
+/** A phone's reading from devicectl's device list; null `devices` means devicectl could not be read. */
+function iosPhysicalReading(devices, udid) {
+	if (!devices) return {
+		name: null,
+		model: null,
+		connection: "unknown"
+	};
+	const device = devices.find((entry) => entry.udid.toUpperCase() === udid.toUpperCase());
+	if (!device) return {
+		name: null,
+		model: null,
+		connection: "disconnected"
+	};
+	return {
+		name: device.name,
+		model: device.model ?? null,
+		connection: isReachable(device) ? "connected" : "disconnected"
+	};
+}
+/**
+* A phone's reading from `adb devices`; null `devices` means adb could not be read. `android --device` and `device lock`
+* record the phone's model as the lease's device name, so the model comes from there.
+*/
+function androidPhysicalReading(devices, serial) {
+	return {
+		name: null,
+		model: null,
+		connection: !devices ? "unknown" : devices.physical.some((entry) => entry.serial === serial) ? "connected" : "disconnected"
+	};
+}
+function physicalDeviceLine(device, now) {
+	const slot = device.slot === "default" ? "" : ` [${device.slot}]`;
+	const name = device.name ?? device.id;
+	const model = device.model && device.model !== name ? `, ${device.model}` : "";
+	const remaining = formatElapsed(Date.parse(device.lease.expiresAt) - now);
+	return `${device.platform}${slot}: ${name} (physical${model}) ${device.connection} -- leased until ${clockTime(device.lease.expiresAt)} (${remaining} left)`;
 }
 //#endregion
 //#region src/commands/status.ts
 const WATCH_GIT_MAX_AGE_MS = 6e4;
-const WATCH_READER_CHECK_MS = 2e3;
+function iosStatusName(ios) {
+	const host = ios.host;
+	return host && !ios.udid ? `${host.device?.name ?? "iOS simulator"} (${host.device ? `iOS ${host.device.runtime.replace(/^iOS /, "")}` : "runtime pending"}) on ${host.machine}` : ios.name ?? ios.udid;
+}
+function iosStatusLines(record, slotLabel) {
+	const out = [];
+	const host = record?.udid ? record.host : void 0;
+	const iosDevices = [record, ...host ? [{
+		host,
+		name: host.device?.name ?? null,
+		udid: "",
+		owned: false,
+		state: host.state ?? "unverified"
+	}] : []];
+	for (const ios of iosDevices) {
+		if (!ios) continue;
+		const booted = ios.state === "Booted" ? chalk.green("booted") : chalk.dim(ios.state.toLowerCase());
+		const owned = ios.owned ? chalk.dim(" (owned)") : "";
+		out.push(`  ios${slotLabel}: ${chalk.cyan(iosStatusName(ios))} ${booted}${owned}${activitySuffix(ios.activity)}${appSuffix(ios.app)}${idleShutdownSuffix(ios.idleShutdown)}`);
+		if (!ios.udid && ios.host?.agent.driver === "agent-device") out.push(chalk.dim(`    agent: ${ios.host.agent.command}`));
+	}
+	return out;
+}
 function formatGb(mb) {
 	return `${(mb / 1024).toFixed(1)} GB`;
 }
@@ -977,12 +1034,14 @@ function statusCommand(program) {
 		for (const line of renderStatus(await readStatus(0), json)) console.log(line);
 	});
 }
-function readStatus(gitMaxAgeMs, simctlListing = null) {
-	return withStateReadCache(() => readStatusFacts(gitMaxAgeMs, simctlListing));
+function readStatus(gitMaxAgeMs, simctlListing = null, archives) {
+	return withStateReadCache(() => readStatusFacts(gitMaxAgeMs, simctlListing, archives));
 }
-async function readStatusFacts(gitMaxAgeMs, simctlListing) {
+async function readStatusFacts(gitMaxAgeMs, simctlListing, cachedArchives) {
 	const cfg = loadConfig$1();
 	const projects = Object.entries(cfg?.projects || {});
+	const iosReads = projects.map(([path]) => readHostedIosStatus(hostedIosPlacements(readWorkspaceState$1(path))));
+	const macosReads = projects.map(([path]) => readHostedMacosStatus(readMacosRecord(path)));
 	const cwdRoot = findServerWorkspace(process.cwd())?.root ?? null;
 	const worktrees = linkedWorktrees([process.cwd(), ...projects.map(([path]) => path)]);
 	const orphanWorktrees = unprovisionedWorktrees(worktrees, projects.map(([p]) => p));
@@ -1017,7 +1076,7 @@ async function readStatusFacts(gitMaxAgeMs, simctlListing) {
 	}
 	const running = await processes;
 	await gitRead;
-	const history = readStats().record?.history;
+	const history = readStats$1().record?.history;
 	const states = [];
 	const labelOnlyRoots = [];
 	const launchesByState = [];
@@ -1029,11 +1088,15 @@ async function readStatusFacts(gitMaxAgeMs, simctlListing) {
 		now: leaseNow
 	});
 	const roots = [];
+	const readPhysicalDevice = physicalDeviceReader();
+	const simulatorUdids = new Set([...Object.keys(simsByUdid), ...projects.flatMap(([, proj]) => projectDeviceSlots(proj).flatMap(({ platforms }) => platforms.ios?.deviceUdid ?? []))].map((udid) => udid.toUpperCase()));
 	for (const [i, [path, proj]] of projects.entries()) {
 		const { metro, supervisor } = running[i];
 		const saved = readWorkspaceState$1(path);
 		const builds = workspaceBuilds(path, saved, history);
 		const web = webFacts(readWebRecord(path));
+		const macosFacts = await macosReads[i];
+		const macos = macosAppState(macosFacts.record);
 		const activeBuild = parseActiveBuild(saved?.[ACTIVE_BUILD_KEY]);
 		roots.push({
 			path,
@@ -1042,7 +1105,8 @@ async function readStatusFacts(gitMaxAgeMs, simctlListing) {
 				platform: activeBuild.platform,
 				pid: activeBuild.claim.pid
 			} : null,
-			browserPids: browserPids(web)
+			browserPids: browserPids(web),
+			macosPids: [macos?.supervisor, macos?.app].flatMap((owner) => owner && (0, process_identity_exports.inspectProcessIdentity)(owner) === "same" ? [owner.pid] : [])
 		});
 		const launches = readWorkspaceLaunches(path);
 		launchesByState.push(launches);
@@ -1060,38 +1124,97 @@ async function readStatusFacts(gitMaxAgeMs, simctlListing) {
 			remote: remoteDeviceState(readRemoteSession(path), easLedger, path),
 			idleStop: readIdleStop(saved),
 			lastStop: metroLastStop(saved, supervisor),
+			idleShutdowns: readDeviceIdleShutdowns(saved),
 			launches,
 			leasedIds: new Set(deviceLeaseStates(leaseFiles, {
 				root: path,
 				now: leaseNow
 			}).flatMap((lease) => lease.mine && !lease.expired && lease.id ? [lease.id] : [])),
-			now: leaseNow
+			now: leaseNow,
+			workspaces: projects.map(([other]) => other)
 		}), web));
 		const state = states[states.length - 1];
-		if (state) Object.assign(state, builds);
-		labelOnlyRoots.push(Boolean(proj.worktreeRoot && !proj.bundleId && !state?.metro && !state?.ios && !state?.android && !state?.web));
+		if (state) {
+			for (const [slot, record] of Object.entries(hostedIosRecords(saved))) if (!parseHostedIosPlacement(record)) state.warnings.push(unreadableHostedIos(slot));
+			for (const [slot, facts] of Object.entries(await iosReads[i])) {
+				const local = slot === "default" ? state.ios : state.slots?.find((entry) => entry.slot === slot)?.ios;
+				const conflict = local?.udid && (local.state === "Booted" || local.state === "unknown");
+				const ios = conflict ? {
+					...local,
+					host: facts.ios.host
+				} : facts.ios;
+				if (conflict) state.warnings.push(`Slot ${slot} records both a local and hosted iOS simulator (${iosStatusName(facts.ios)}); run stim stop to reconcile them.`);
+				if (slot === "default") state.ios = ios;
+				else {
+					state.slots ??= [];
+					const savedSlot = state.slots.find((entry) => entry.slot === slot);
+					if (savedSlot) savedSlot.ios = ios;
+					else state.slots.push({
+						slot,
+						ios,
+						android: null
+					});
+				}
+				if (facts.warning) state.warnings.push(facts.warning);
+				state.live ||= facts.ios.state === "ready";
+			}
+			const tunnel = readMetroTunnel(path);
+			if (state.metro && tunnel?.kind === "managed" && tunnel.port === state.metro.port && pidExists(tunnel.pid)) state.metro.tunnel = {
+				provider: tunnel.provider,
+				url: tunnel.url
+			};
+			if (macos) {
+				state.macos = macos;
+				if (macosFacts.warning) state.warnings.push(macosFacts.warning);
+				state.live ||= macos.state === "running" || macos.state === "orphaned" || macos.build.state === "running";
+			}
+			Object.assign(state, builds, workspacePhase(state.live, saved, { now: leaseNow }), {
+				platforms: detectPlatforms(path, resolveSettings({
+					projectPath: path,
+					gitCommonDir: gitCommonDirOnDisk(path),
+					repoRoot: state.worktree?.path ?? path
+				})),
+				recording: { enabled: workspaceRecordingEnabled(path, proj, cfg, process.env) }
+			});
+		}
+		const physicalDevices = physicalDeviceStates(leaseFiles, parseWorkspaceLeases(saved?.deviceLeases), {
+			root: path,
+			now: leaseNow,
+			simulatorUdids,
+			read: readPhysicalDevice
+		});
+		if (state && physicalDevices.length) state.physicalDevices = physicalDevices;
+		labelOnlyRoots.push(Boolean(proj.worktreeRoot && !proj.bundleId && !state?.metro && !state?.ios && !state?.android && !state?.web && !state?.macos));
 	}
+	applyStatusMeasures(states, worktrees);
+	readLogDerivedFacts(states);
 	const tables = createDeviceProcessTables();
 	readDeviceProcesses(states, tables, {
 		projects,
 		launchesByState
 	});
+	readMetroReverses(states, launchesByState);
 	const sims = Object.values(simsByUdid);
 	const simNames = Object.fromEntries(sims.map((sim) => [sim.udid.toUpperCase(), sim.name]));
-	const machine = readMachineUsage({
+	const machine = await readMachineUsage({
 		states,
 		roots,
 		simNames,
 		tables,
 		busy: sims.some((sim) => sim.state === "Booted")
 	});
+	const archives = cachedArchives ?? readArchives();
+	const maxCount = machineNumber("archive.maxCount", cfg, process.env);
 	return {
+		archived: linkReplacedArchives(archives.slice(0, maxCount.value ?? 200), states.map((state) => state.path)),
+		archivedUsage: archivedUsage(archives),
 		projects,
 		states,
 		labelOnlyRoots,
 		leases,
 		leaseNow,
 		orphanWorktrees,
+		worktrees,
 		simsAvailable,
 		simctlError,
 		cwdRoot,
@@ -1101,6 +1224,48 @@ async function readStatusFacts(gitMaxAgeMs, simctlListing) {
 		simNames
 	};
 }
+/** Sets the facts status derives from workspace logs, the running build's record and its detail file. */
+function readLogDerivedFacts(states) {
+	const now = Date.now();
+	for (const state of states) {
+		if (state.metro) {
+			const bundle = metroBundleState(tailLines(join$1(workspaceLogsDir$1(state.path), "metro.ndjson")) ?? [], {
+				running: state.metro.running,
+				now
+			});
+			if (bundle) state.metro.bundle = bundle;
+			else delete state.metro.bundle;
+		}
+		if (state.build?.state === "running") {
+			const record = parseActiveBuild(readWorkspaceState$1(state.path)?.[ACTIVE_BUILD_KEY]);
+			if (!record) {
+				state.build = null;
+				continue;
+			}
+			const report = buildReport(record, {
+				state: activeBuildState(record.claim),
+				history: void 0
+			});
+			const { outcome, expectedMs, expectedPhaseMs, basis, plannedPhases } = state.build;
+			state.build = record.estimate || record.startedAt !== state.build.startedAt ? report : {
+				...report,
+				outcome,
+				expectedMs,
+				expectedPhaseMs: report.phase === state.build.phase ? expectedPhaseMs : null,
+				basis,
+				plannedPhases
+			};
+			const detail = record.phase === "compile" ? readBuildDetail(state.path, record.claim.claimId) : null;
+			if (detail) state.build.detail = detail;
+			else delete state.build.detail;
+		}
+	}
+}
+function phaseMarker({ phase, live, warmStep }) {
+	if (phase === "warming") return chalk.cyan(` [warming: ${warmStep}]`);
+	if (phase === "ready") return chalk.green(" [ready]");
+	return live ? "" : chalk.dim(" [idle]");
+}
 function browserPids(web) {
 	if (!web) return [];
 	const chrome = web.record.chromeProcess?.pid;
@@ -1108,37 +1273,48 @@ function browserPids(web) {
 	return web.status === "orphaned" && chrome ? [chrome] : [];
 }
 /**
-* Attributes the host process table to its owners. Reads the table only when a simulator is booted, a workspace is
-* live or a build runs, so an idle machine runs no `ps`.
+* Attributes the host process table and the processes' footprints to their owners, and sets each environment's
+* `memoryMb` from them. Reads both only when a simulator is booted, a workspace is live or a build runs, so an idle
+* machine runs no `ps` and keeps the estimate.
 */
-function readMachineUsage({ states, roots, simNames, tables, busy }) {
+async function readMachineUsage({ states, roots, simNames, tables, busy }) {
 	const processes = busy || states.some((state) => state.live || state.build?.state === "running") ? tables.host() : null;
-	return processes ? attributeMachineUsage({
+	if (!processes) return null;
+	const footprints = await readFootprints();
+	const machine = attributeMachineUsage({
 		processes,
+		footprints,
 		environments: states,
 		roots,
 		simNames
-	}) : null;
+	});
+	applyMachineMemory(states, machine);
+	return machine;
 }
 /**
 * Rereads only the error counts, device activity and machine usage. With `machine`, and when the snapshot measured
 * machine usage, it reads the host process table again; it reuses every other subprocess fact of the full read.
 */
-function refreshLightFacts(snapshot, machine) {
-	if (machine && snapshot.machine) snapshot.tables = {
-		host: createDeviceProcessTables().host,
-		android: snapshot.tables.android
+async function refreshLightFacts(snapshot, machine) {
+	const fresh = createDeviceProcessTables();
+	snapshot.tables = {
+		host: machine && snapshot.machine ? fresh.host : snapshot.tables.host,
+		android: snapshot.tables.android,
+		tcpConnections: fresh.tcpConnections,
+		clients: fresh.host
 	};
 	withStateReadCache(() => {
 		for (const state of snapshot.states) state.logs = logFacts(state.path);
+		applyStatusMeasures(snapshot.states, snapshot.worktrees);
+		readLogDerivedFacts(snapshot.states);
 		readDeviceProcesses(snapshot.states, snapshot.tables, null);
 	});
-	if (machine && snapshot.machine) snapshot.machine = readMachineUsage({
+	if (machine && snapshot.machine) snapshot.machine = await readMachineUsage({
 		...snapshot,
 		busy: true
 	});
 }
-function renderStatus({ projects, states, labelOnlyRoots, leases, leaseNow, orphanWorktrees, simsAvailable, simctlError, cwdRoot, machine }, json) {
+function renderStatus({ archived, archivedUsage: usage, projects, states, labelOnlyRoots, leases, leaseNow, orphanWorktrees, simsAvailable, simctlError, cwdRoot, machine }, json) {
 	const out = [];
 	const totalMemoryMb = Math.round(totalmem() / 1048576);
 	const cap = capacity(states, totalMemoryMb);
@@ -1153,20 +1329,26 @@ function renderStatus({ projects, states, labelOnlyRoots, leases, leaseNow, orph
 			})
 		};
 	});
+	const maintenance = maintenanceStatus();
 	if (json) {
 		out.push(JSON.stringify({
-			environments: states.map((state, i) => labelOnlyRoots[i] ? {
+			environments: states.map((state, i) => withDerivedFacts(labelOnlyRoots[i] ? {
 				...state,
 				labelOnly: true
-			} : state),
+			} : state)),
+			archived,
+			archivedUsage: usage,
 			capacity: cap,
 			deviceLeases: leases,
-			unprovisionedWorktrees: orphanWorktrees,
+			unprovisionedWorktrees: orphanWorktrees.map(withGitChip),
 			simctlAvailable: simsAvailable,
-			machine
+			machine,
+			maintenance
 		}));
 		return out;
 	}
+	out.push(...maintenanceLines(maintenance).map((line) => chalk.dim(line)));
+	if (usage.count) out.push(`Archived: ${plural(usage.count, "workspace")}, ${formatBytes(usage.bytes)}`);
 	if (projects.length === 0 && orphanWorktrees.length === 0) {
 		out.push(chalk.dim("No projects registered."));
 		for (const pool of pools) {
@@ -1182,12 +1364,16 @@ function renderStatus({ projects, states, labelOnlyRoots, leases, leaseNow, orph
 		if (!state) continue;
 		const shortcut = projectShortcut(path, proj);
 		const marker = path === cwdRoot ? chalk.bold.cyan(`* ${shortcut}`) : shortcut;
-		const idle = state.live ? "" : chalk.dim(" [idle]");
+		const idle = phaseMarker(state);
 		out.push(`\n${marker}${idle} ${chalk.dim(`(${path})`)}`);
 		out.push(labelOnlyRoots[i] ? chalk.dim("  worktree root (holds the label; the app registers its own entry)") : chalk.dim(`  app: ${proj.bundleId ?? "?"} (${proj.isExpo ?? detectIsExpo(path) ? "expo" : "bare"})`));
 		if (state.metro) {
 			const label = state.metro.running ? chalk.green(`running (pid ${state.metro.pid})`) : state.metro.idleStop ? chalk.dim(`stopped (idle) after ${state.metro.idleStop.idleMinutes}m; \`stim start\`, \`ios\` or \`android\` restarts it`) : state.metro.lastStop ? chalk.dim(`not running${state.metro.lastStop.reason === "vanished" ? "" : ` since ${state.metro.lastStop.at}`}; ${describeMetroLastStop(state.metro.lastStop)}`) : chalk.dim("not running");
 			out.push(`  metro: port ${state.metro.port} ${label}`);
+			if (state.metro.tunnel) {
+				const { provider, url } = state.metro.tunnel;
+				out.push(`  tunnel: ${provider}${provider === "tailscale" ? " (tailnet-only)" : ""} ${url}`);
+			}
 		}
 		if (state.supervisor) {
 			const health = state.supervisor.healthy ? chalk.green("healthy") : chalk.yellow("not answering");
@@ -1200,6 +1386,7 @@ function renderStatus({ projects, states, labelOnlyRoots, leases, leaseNow, orph
 		}
 		out.push(...lastBuildsLines(state.lastBuilds));
 		if (state.worktree?.git) out.push(chalk.dim(`  git: ${gitSummaryText(state.worktree.git)}`));
+		for (const agent of state.agents ?? []) out.push(chalk.dim(`  agent: ${agentLine(agent)}`));
 		if (state.logs) {
 			const n = state.logs.errorsSinceMarker;
 			const errs = n > 0 ? chalk.yellow(` (${n} error${n === 1 ? "" : "s"} since the last marker)`) : "";
@@ -1211,23 +1398,31 @@ function renderStatus({ projects, states, labelOnlyRoots, leases, leaseNow, orph
 			android: state.android
 		}, ...state.slots ?? []]) {
 			const slotLabel = deviceState.slot === "default" ? "" : ` [${deviceState.slot}]`;
-			if (deviceState.ios) {
-				const booted = deviceState.ios.state === "Booted" ? chalk.green("booted") : chalk.dim(deviceState.ios.state.toLowerCase());
-				const owned = deviceState.ios.owned ? chalk.dim(" (owned)") : "";
-				out.push(`  ios${slotLabel}: ${chalk.cyan(deviceState.ios.name ?? deviceState.ios.udid)} ${booted}${owned}${activitySuffix(deviceState.ios.activity)}${appSuffix(deviceState.ios.app)}`);
-			}
+			out.push(...iosStatusLines(deviceState.ios, slotLabel));
 			if (deviceState.android) {
 				const kind = deviceState.android.physical ? chalk.dim("(physical)") : chalk.dim("(emulator)");
 				const observed = deviceState.android.state ? ` ${deviceState.android.state}${deviceState.android.serial ? ` (${deviceState.android.serial})` : ""}` : "";
-				out.push(`  android${slotLabel}: ${chalk.cyan(deviceState.android.name)} ${kind}${observed}${deviceState.android.owned ? chalk.dim(" (owned)") : ""}${activitySuffix(deviceState.android.activity)}${appSuffix(deviceState.android.app)}`);
+				out.push(`  android${slotLabel}: ${chalk.cyan(deviceState.android.name)} ${kind}${observed}${deviceState.android.owned ? chalk.dim(" (owned)") : ""}${activitySuffix(deviceState.android.activity)}${appSuffix(deviceState.android.app)}${idleShutdownSuffix(deviceState.android.idleShutdown)}`);
 			}
 		}
+		if (state.macos) {
+			const host = state.macos.host;
+			const where = host ? ` on ${host.machine} as ${host.bundleId}${chalk.dim(` (session ${host.session})`)}` : "";
+			const build = state.macos.build;
+			const placement = build.buildMachine === void 0 ? "" : `; build machine ${build.buildMachine}, built on ${build.builtOn ?? "none"}`;
+			out.push(`  macOS ${state.macos.product}: ${state.macos.state}${where}; build ${build.state}${placement}`);
+			if (host?.agent.driver === "agent-device") out.push(chalk.dim(`    agent: ${host.agent.command}`));
+		}
 		if (state.web) {
 			const browser = state.web.running ? chalk.green(`running (pid ${state.web.pid}, DevTools ${state.web.cdpEndpoint})`) : chalk.dim("not running");
-			out.push(`  web: ${chalk.cyan(state.web.url)} ${browser}${state.web.headless ? "" : chalk.dim(" (headed)")}`);
+			const page = state.web.page;
+			const failed = page?.state === "failed" ? ` -- ${chalk.yellow(`page failed: ${page.error}`)}` : "";
+			out.push(`  web: ${chalk.cyan(page?.url ?? state.web.url)} ${browser}${state.web.headless ? "" : chalk.dim(" (headed)")}${activitySuffix(state.web.activity)}${failed}`);
 		}
+		for (const device of state.physicalDevices ?? []) out.push(`  ${physicalDeviceLine(device, leaseNow)}`);
 		for (const remote of state.remoteDevices ?? []) out.push(`  ${remoteDeviceLine(remote)}`);
 		for (const w of state.warnings) out.push(chalk.yellow(`  ! ${w}`));
+		for (const note of state.issues.filter((issue) => issue.severity === "info")) out.push(chalk.dim(`  - ${note.message}`));
 	}
 	for (const pool of pools) {
 		if (pool.error) out.push(chalk.yellow(`\n${pool.error} ${POOL_SETTING_REMEDY}`));
@@ -1242,7 +1437,7 @@ function renderStatus({ projects, states, labelOnlyRoots, leases, leaseNow, orph
 		out.push(chalk.dim(`\nWorktrees with no environment (${orphanWorktrees.length}):`));
 		for (const w of orphanWorktrees) out.push(chalk.dim(`  ${orphanWorktreeLine(w)}`));
 	}
-	out.push(chalk.dim(`\n${cap.liveCount} live environment(s), roughly ${formatGb(cap.committedMb)} of ${formatGb(cap.totalMemoryMb)} committed.`));
+	out.push(chalk.dim(machine?.memorySource === "footprint" ? `\n${cap.liveCount} live environment(s) use ${formatGb(cap.committedMb)} of ${formatGb(cap.totalMemoryMb)}.` : `\n${cap.liveCount} live environment(s), roughly ${formatGb(cap.committedMb)} of ${formatGb(cap.totalMemoryMb)} committed.`));
 	const volumes = readVolumes(cwdRoot || process.cwd());
 	const line = diskLine(volumes);
 	if (line) {
@@ -1257,16 +1452,31 @@ function renderStatus({ projects, states, labelOnlyRoots, leases, leaseNow, orph
 }
 async function watchStatus(json) {
 	let last = null;
+	let archiveStamp = null;
+	let archives;
 	let snapshot = null;
 	let sources = null;
+	const measurer = createStatusMeasurer({ updated: () => scheduler.trigger("light") });
 	const scheduler = createRefreshScheduler({
 		debounceMs: 250,
 		lightIntervalMs: WATCH_LIGHT_INTERVAL_MS,
 		run: async (kind) => {
+			triggerMaintenance("status-watch");
 			let text;
 			try {
-				if (kind === "light" && snapshot) refreshLightFacts(snapshot, json);
-				else snapshot = await readStatus(WATCH_GIT_MAX_AGE_MS, sources?.simulatorListing());
+				if (kind === "light" && snapshot) await refreshLightFacts(snapshot, json);
+				else {
+					let stamp = null;
+					try {
+						stamp = statSync$1(archiveRoot()).mtimeMs;
+					} catch {}
+					if (archives === void 0 || stamp !== archiveStamp) {
+						archives = readArchives();
+						archiveStamp = stamp;
+					}
+					snapshot = await readStatus(WATCH_GIT_MAX_AGE_MS, sources?.simulatorListing(), archives);
+				}
+				measurer.schedule(snapshot.states, snapshot.worktrees);
 				text = renderStatus(snapshot, json).join("\n");
 			} catch (error) {
 				console.error(chalk.red(String(error?.message || error)));
@@ -1281,24 +1491,17 @@ async function watchStatus(json) {
 	});
 	const fallback = setInterval(() => scheduler.trigger("full"), WATCH_FALLBACK_MS);
 	const machine = setInterval(() => json && snapshot?.machine && scheduler.trigger("light"), WATCH_LIGHT_INTERVAL_MS);
-	const parent = process.ppid;
-	const stdout = fstatSync$1(1);
-	const linuxPipe = process.platform === "linux" && (stdout.isFIFO() || stdout.isSocket());
-	const reader = setInterval(() => {
-		if (linuxPipe && process.ppid !== parent) finish();
-		else process.stdout.write("");
-	}, WATCH_READER_CHECK_MS);
 	const finish = () => {
 		clearInterval(fallback);
 		clearInterval(machine);
-		clearInterval(reader);
+		stopReader();
 		scheduler.stop();
 		sources?.stop();
 		process.exit(0);
 	};
+	const stopReader = watchStdoutReader(finish);
 	process.on("SIGINT", finish);
 	process.on("SIGTERM", finish);
-	process.stdout.on("error", finish);
 	sources = watchStatusSources({
 		home: getConfigDir(),
 		onChange: (kind) => scheduler.trigger(kind)
@@ -1314,6 +1517,10 @@ async function readGitInto(worktrees, orphans, maxAgeMs) {
 	});
 	for (const worktree of worktrees) worktree.git = byPath.get(worktree.path) ?? null;
 }
+function agentLine({ tool, title, sessionId, lastActiveAt }) {
+	const at = lastActiveAt ? `, active ${lastActiveAt}` : "";
+	return `${tool === "codex" ? "Codex" : "Claude Code"} ${title ? `"${title}"` : sessionId}${at}`;
+}
 function orphanWorktreeLine(w) {
 	return `${w.path}${w.branch ? ` [${w.branch}]` : ""}${w.git ? ` -- ${gitSummaryText(w.git)}` : ""}`;
 }
@@ -1324,7 +1531,11 @@ function lastBuildsLines(reports) {
 function lastBuildText(report) {
 	const source = report.cacheHit ? `${report.cacheHit} cache` : report.status === "ok" ? "compiled" : "no cache hit";
 	const took = report.durationMs === null ? "" : ` in ${formatDuration(report.durationMs)}`;
-	return `${report.platform} ${report.status === "ok" ? source : `failed (${report.errorCode ?? "error"}), ${source}`}${took}`;
+	const placement = report.buildMachine === void 0 ? "" : `; build machine ${report.buildMachine}, built on ${report.builtOn ?? (report.cacheHit ? "none (cache)" : "none")}`;
+	return `${report.platform} ${report.status === "ok" ? source : `failed (${report.errorCode ?? "error"}), ${source}`}${took}${placement}`;
+}
+function idleShutdownSuffix(record) {
+	return record ? chalk.dim(` -- shut down after ${record.idleMinutes}m idle at ${record.at} (devices.idleShutdownMinutes)`) : "";
 }
 function activitySuffix(activity) {
 	const label = activityLabel(activity, Date.now());
@@ -1378,6 +1589,28 @@ function readDeviceProcesses(states, tables, apps) {
 				});
 			}
 		}
+		const web = state.web;
+		const port = web?.cdpEndpoint ? Number(new URL(web.cdpEndpoint).port) : null;
+		if (web?.running && port) {
+			web.page = readWebPage(state.path);
+			const ownPids = [web.pid, web.supervisorPid].filter((pid) => pid !== null);
+			web.activity = statusActivity(readWebActivity({
+				port,
+				ownPids,
+				workspace: state.path
+			}, tables));
+		}
+	}
+}
+function readMetroReverses(states, launchesByState) {
+	for (const [i, state] of states.entries()) for (const target of metroReverseTargets(state, launchesByState[i])) {
+		const listing = getExecutor().runFileQuiet("adb", [
+			"-s",
+			target.serial,
+			"reverse",
+			"--list"
+		], { timeoutMs: 5e3 });
+		if (listing !== null && !hasMetroReverse(listing, target.metroPort)) addReverseMissingIssue(state, target);
 	}
 }
 function appSuffix(app) {
@@ -1388,7 +1621,7 @@ function appSuffix(app) {
 }
 function linkedWorktrees(paths) {
 	return [...new Set(paths.flatMap((path) => gitCommonDirOnDisk(path) ?? []))].flatMap((common) => {
-		const repository = basename(common) === ".git" ? dirname(common) : common;
+		const repository = basename$1(common) === ".git" ? dirname$1(common) : common;
 		return linkedWorktreesOnDisk(common).map((entry) => Object.assign(entry, { repository }));
 	});
 }
@@ -1404,7 +1637,7 @@ function workspaceBuilds(path, saved, history) {
 function workspaceBuild(path, saved, history) {
 	const record = parseActiveBuild(saved?.[ACTIVE_BUILD_KEY]);
 	if (!record) return null;
-	const projectKey = statsProjectKey({
+	const projectKey = statsProjectKey$1({
 		root: path,
 		commonDir: gitCommonDir(path),
 		repoRoot: repoRoot(path)
@@ -1414,6 +1647,32 @@ function workspaceBuild(path, saved, history) {
 		history: history?.[projectKey]
 	});
 }
+const PHYSICAL_DEVICE_LIST_TIMEOUT_MS = 5e3;
+const PHYSICAL_DEVICE_LIST_MAX_AGE_MS = 3e4;
+const physicalDeviceLists = {};
+function freshList(entry, read) {
+	const now = Date.now();
+	return entry && now - entry.at < PHYSICAL_DEVICE_LIST_MAX_AGE_MS ? entry : {
+		at: now,
+		devices: read()
+	};
+}
+function physicalDeviceReader() {
+	return (platform, id) => {
+		if (platform === "ios") {
+			physicalDeviceLists.ios = freshList(physicalDeviceLists.ios, () => readIosDevices({ timeoutMs: PHYSICAL_DEVICE_LIST_TIMEOUT_MS }));
+			return iosPhysicalReading(physicalDeviceLists.ios.devices, id);
+		}
+		physicalDeviceLists.android = freshList(physicalDeviceLists.android, () => {
+			try {
+				return listAdbDevices({ timeoutMs: PHYSICAL_DEVICE_LIST_TIMEOUT_MS });
+			} catch {
+				return null;
+			}
+		});
+		return androidPhysicalReading(physicalDeviceLists.android.devices, id);
+	};
+}
 function androidRuntimeReader() {
 	const resolve = ownedAvdSerialResolver({ timeoutMs: 5e3 });
 	return (avdName) => readAndroidRuntime(() => resolve(avdName));
@@ -1494,7 +1753,7 @@ async function supervisorFacts(path, proj, metroResolution, lookup) {
 	};
 }
 function logFacts(path) {
-	const dir = workspaceLogsDir(path);
+	const dir = workspaceLogsDir$1(path);
 	if (!existsSync$1(dir)) return null;
 	try {
 		return {