stim 1.20.2 → 1.22.0

package/dist/activity-CMLmzp7o.mjs

@@ -0,0 +1,1397 @@
+import { c as declareSpawnsOn, f as stopDeclaringSpawnsOn, g as process_identity_exports, t as getExecutor, x as ownership_claim_exports } from "./exec-DEoAhcze.mjs";
+import { m as workspaceLogsDir$1, v as withDirLock$1, y as withDirLockAsync$1 } from "./paths-DQtTgsBf.mjs";
+import { U as parseDeviceSlotKey, V as deviceSlotKey, d as getConfigDir, q as validateDeviceSlot } from "./config-DlrsduwG.mjs";
+import { a as formatElapsed, i as formatDuration, m as shortHash } from "./command-output-gwpm28fu.mjs";
+import { n as runOperationFileQuiet } from "./operation-exec-BW0em61G.mjs";
+import { c as withWorkspaceStateLock, d as writeWorkspaceState, l as withWorkspaceStateLockAsync, n as clearWorkspaceStateKeys, r as readWorkspaceState$1 } from "./workspace-state-U08dEzhG.mjs";
+import { h as resolveBuild } from "./build-cache-Dv7RN200.mjs";
+import { randomBytes } from "node:crypto";
+import { closeSync, fstatSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join, resolve } from "node:path";
+import { ambientContext } from "@stim-cli/core";
+import { agentDeviceStateDirs, isJsonObject, readViewedDevices } from "@stim-cli/core/state";
+import { readFile, readdir } from "node:fs/promises";
+//#region src/devices/automation-tools.ts
+const AUTOMATION_TOOLS = [
+	{
+		tool: "agent-browser",
+		platforms: ["web"],
+		cdp: /agent-browser/i
+	},
+	{
+		tool: "agent-device",
+		platforms: [
+			"ios",
+			"android",
+			"web"
+		],
+		host: /agent-device/i,
+		cdp: /agent-device/i
+	},
+	{
+		tool: "argent",
+		platforms: [
+			"ios",
+			"android",
+			"web"
+		],
+		host: /\/bin\/[\w-]+\/(simulator-server(\.exe)?\s+(ios|android|android_device)|ax-service)\b|com\.argent\.androiddevtools/,
+		instrumentation: /com\.argent\.androiddevtools/,
+		cdp: /@swmansion\/argent\/dist\/tool-server/
+	},
+	{
+		tool: "idb",
+		platforms: ["ios"],
+		host: /idb_companion/
+	},
+	{
+		tool: "maestro",
+		platforms: ["ios", "android"],
+		host: /maestro/i
+	},
+	{
+		tool: "appium",
+		platforms: ["ios", "android"],
+		host: /appium|WebDriverAgent/i
+	},
+	{
+		tool: "xcodebuild",
+		platforms: ["ios"],
+		host: /\bxcodebuild\b.*\btest(-without-building)?\b/
+	},
+	{
+		tool: "simctl",
+		platforms: ["ios"],
+		host: /\bsimctl\s+(io|spawn)\b/
+	},
+	{
+		tool: "uiautomator",
+		platforms: ["android"],
+		instrumentation: /uiautomator/
+	},
+	{
+		tool: "instrumentation",
+		platforms: ["android"],
+		instrumentation: /androidx\.test|\binstrument\b/
+	},
+	{
+		tool: "chrome-devtools-mcp",
+		platforms: ["web"],
+		cdp: /chrome-devtools-mcp/i
+	},
+	{
+		tool: "playwright",
+		platforms: ["web"],
+		cdp: /playwright/i
+	},
+	{
+		tool: "puppeteer",
+		platforms: ["web"],
+		cdp: /puppeteer/i
+	}
+];
+const HOST_EXCLUSIONS = [/\bsimctl\s+spawn\b.*\blog\s+stream\b/, /\blogcat\b/];
+/** Stim's own DevTools clients: the browser supervisor, `stim-frames` in stim-server, Stim Desktop, the stim CLI. */
+const CDP_EXCLUSIONS = [/\bstim-(frames|server|web)\b|StimDesktop|\/stim(-cli)?\/(dist|bin)\/|\/bin\/stim(\s|$)|^stim(\s|$)/];
+function namesDevice(command, id) {
+	const escaped = id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	return new RegExp(`(^|[^A-Za-z0-9])${escaped}([^A-Za-z0-9]|$)`).test(command);
+}
+/** The tool a host process drives the device `id` with, or null when the command does not name the device. */
+function hostDriverTool(command, platform, id) {
+	if (!namesDevice(command, id) || HOST_EXCLUSIONS.some((pattern) => pattern.test(command))) return null;
+	return AUTOMATION_TOOLS.find((entry) => entry.platforms.includes(platform) && entry.host?.test(command))?.tool ?? null;
+}
+/** The tool behind an on-device process's arguments, or null when it is not instrumentation. */
+function instrumentationTool(args) {
+	return AUTOMATION_TOOLS.find((entry) => entry.platforms.includes("android") && entry.instrumentation?.test(args))?.tool ?? null;
+}
+/**
+* The tool a DevTools client's command line names, or null for Stim's own clients. A client no entry names is
+* reported by its script or executable name.
+*/
+function cdpClientTool(command) {
+	if (CDP_EXCLUSIONS.some((pattern) => pattern.test(command))) return null;
+	const known = AUTOMATION_TOOLS.find((entry) => entry.platforms.includes("web") && entry.cdp?.test(command));
+	if (known) return known.tool;
+	const [executable = "", script] = command.trim().split(/\s+/);
+	const name = basename(executable);
+	return (/^(node|bun|deno|python3?)$/.test(name) && script ? basename(script) : name) || "unknown DevTools client";
+}
+//#endregion
+//#region src/engine/build-lock.ts
+const LOCK_SUFFIX$1 = ".lock";
+const WAIT_POLL_MS = 1e3;
+const WAIT_PROGRESS_MS = 3e4;
+const WAIT_CEILING_MS = 54e5;
+function sleepAsync(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function segment(value) {
+	return String(value).replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^\.+/, "") || "unknown";
+}
+function buildLocksDir() {
+	return join(getConfigDir(), "build-locks");
+}
+function buildLockPath(platform, key) {
+	return join(buildLocksDir(), `${segment(platform)}-${segment(key)}${LOCK_SUFFIX$1}`);
+}
+function label(platform) {
+	return `${platform} build`;
+}
+function toRecord(holder) {
+	const details = holder.details;
+	return {
+		pid: holder.owner.pid,
+		projectRoot: typeof details.projectRoot === "string" ? details.projectRoot : null,
+		startedAt: holder.startedAt || null,
+		logFile: typeof details.logFile === "string" ? details.logFile : null
+	};
+}
+function readBuildLock(pathOrSpec) {
+	const path = typeof pathOrSpec === "string" ? pathOrSpec : buildLockPath(pathOrSpec.platform, pathOrSpec.key);
+	const survey = (0, ownership_claim_exports.readClaimSet)(path);
+	const holder = survey.live[0] ?? survey.dead[0];
+	return holder ? toRecord(holder) : null;
+}
+function acquireBuildLock({ platform, key, root = null, logFile = null }) {
+	const path = buildLockPath(platform, key);
+	const attempt = (0, ownership_claim_exports.tryAcquireClaim)({
+		root: path,
+		mode: "exclusive",
+		label: label(platform),
+		details: {
+			projectRoot: root,
+			logFile
+		}
+	});
+	const reaped = attempt.reaped[0];
+	if (attempt.acquired) {
+		const handle = {
+			acquired: true,
+			path,
+			lock: {
+				pid: attempt.acquired.owner.pid,
+				projectRoot: root,
+				startedAt: attempt.acquired.startedAt,
+				logFile
+			},
+			claim: attempt.acquired
+		};
+		declareSpawnsOn(ambientContext(), attempt.acquired);
+		return reaped ? {
+			...handle,
+			tookOver: toRecord(reaped)
+		} : handle;
+	}
+	if (attempt.pending) (0, ownership_claim_exports.releaseClaim)(attempt.pending);
+	const holder = attempt.held ?? attempt.waitingFor?.[0];
+	return holder ? {
+		held: toRecord(holder),
+		path
+	} : { path };
+}
+function releaseBuildLock(handle) {
+	stopDeclaringSpawnsOn(ambientContext(), handle?.claim);
+	return (0, ownership_claim_exports.releaseClaim)(handle?.claim);
+}
+function listBuildLocks() {
+	const dir = buildLocksDir();
+	let names;
+	try {
+		names = readdirSync(dir);
+	} catch {
+		return [];
+	}
+	const locks = [];
+	for (const name of names) {
+		if (!name.endsWith(LOCK_SUFFIX$1)) continue;
+		const path = join(dir, name);
+		try {
+			if (!statSync(path).isDirectory()) continue;
+		} catch {
+			continue;
+		}
+		const stem = name.slice(0, -5);
+		const cut = stem.indexOf("-");
+		const survey = (0, ownership_claim_exports.readClaimSet)(path);
+		const holder = survey.live[0] ?? survey.dead[0];
+		const info = holder ? toRecord(holder) : null;
+		locks.push({
+			path,
+			name,
+			platform: cut > 0 ? stem.slice(0, cut) : stem,
+			key: cut > 0 ? stem.slice(cut + 1) : null,
+			pid: info?.pid ?? null,
+			projectRoot: info?.projectRoot ?? null,
+			startedAt: info?.startedAt ?? null,
+			logFile: info?.logFile ?? null,
+			alive: survey.live.length > 0,
+			unresolved: survey.unresolved.length > 0
+		});
+	}
+	return locks;
+}
+function waitingLine({ projectRoot, pid, elapsedMs, logFile }) {
+	const where = projectRoot || "another workspace";
+	const tail = logFile ? ` -- tail ${logFile}` : "";
+	return `${"build".padEnd(11)} waiting on ${where} (pid ${pid ?? "?"}, ${formatElapsed(elapsedMs)} elapsed)${tail} -- stim guide lifecycle concurrency`;
+}
+function takeoverLine({ projectRoot, pid, logFile, startedAt = null, now = Date.now }) {
+	const where = projectRoot || "another workspace";
+	const started = startedAt ? Date.parse(startedAt) : NaN;
+	const ago = Number.isFinite(started) ? ` (it started ${formatElapsed(now() - started)} ago)` : "";
+	const tail = logFile ? ` -- read ${logFile} before this one finishes` : "";
+	return `RETRY: ${where}'s build of this fingerprint (pid ${pid ?? "?"}) FAILED without an artifact${ago}, and this run rebuilds the SAME inputs, so expect the same failure unless something changed${tail}`;
+}
+async function waitForBuild({ platform, key, resolve = resolveBuild, intervalMs = WAIT_POLL_MS, progressMs = WAIT_PROGRESS_MS, ceilingMs = WAIT_CEILING_MS, out = () => {}, now = Date.now, sleep = sleepAsync }) {
+	const path = buildLockPath(platform, key);
+	const started = now();
+	let lastProgress = started;
+	let holder = readBuildLock(path);
+	for (;;) {
+		const hit = resolve(platform, key);
+		if (hit) return {
+			hit,
+			waitedMs: now() - started
+		};
+		const survey = (0, ownership_claim_exports.readClaimSet)(path);
+		const unresolved = survey.unresolved[0];
+		if (unresolved) throw new ownership_claim_exports.ClaimRefusedError({
+			claimPath: unresolved.path,
+			root: path,
+			label: label(platform),
+			reason: unresolved.reason
+		});
+		const live = survey.live[0];
+		if (live) holder = toRecord(live);
+		else {
+			const dead = survey.dead[0];
+			if (dead) return {
+				builderFailed: `the builder (pid ${dead.owner.pid}) is gone`,
+				holder: toRecord(dead),
+				waitedMs: now() - started
+			};
+			return {
+				lockReleased: true,
+				holder,
+				waitedMs: now() - started
+			};
+		}
+		const elapsed = now() - started;
+		if (elapsed >= ceilingMs) {
+			const err = /* @__PURE__ */ new Error(`Waited ${formatElapsed(elapsed)} for ${holder?.projectRoot || "another workspace"}'s ${platform} build of ${key} without an artifact, and pid ${holder?.pid} is still the live holder. The lock is ${path}; remove it if that process is not really building:\n  ${(0, ownership_claim_exports.claimRemoveCommand)(path)}`);
+			err.code = "STIM_BUILD_WAIT_TIMEOUT";
+			err.lockPath = path;
+			err.holder = holder ?? void 0;
+			throw err;
+		}
+		if (now() - lastProgress >= progressMs) {
+			lastProgress = now();
+			out(waitingLine({
+				projectRoot: holder.projectRoot,
+				pid: holder.pid,
+				elapsedMs: elapsed,
+				logFile: holder.logFile
+			}));
+		}
+		await sleep(intervalMs);
+	}
+}
+async function waitForSharedBuild({ platform, key, fingerprint, root, logFile, command, acquire, wait, now, phase, waitingOn, warn, out }) {
+	const waitStarted = now();
+	let failedHolder;
+	let released = null;
+	for (;;) {
+		let attempt = null;
+		try {
+			attempt = acquire({
+				platform,
+				key,
+				root,
+				logFile
+			});
+		} catch (err) {
+			const refusal = (0, ownership_claim_exports.claimFailure)(err, command);
+			if (refusal) return { refusal };
+			warn(`could not take the build lock: ${err?.message || err}; building anyway`);
+		}
+		if (attempt?.acquired) {
+			const previous = attempt.tookOver ?? failedHolder;
+			if (previous) warn(takeoverLine(previous));
+			waitingOn(null);
+			return {
+				refusal: null,
+				lock: attempt,
+				hit: null,
+				released
+			};
+		}
+		if (!attempt?.held) {
+			waitingOn(null);
+			return {
+				refusal: null,
+				lock: null,
+				hit: null,
+				released
+			};
+		}
+		released = null;
+		const holder = attempt.held;
+		const who = holder.projectRoot || "another workspace";
+		phase(`${who} is already building ${shortHash(fingerprint)} (pid ${holder.pid})${holder.logFile ? ` -- tail ${holder.logFile}` : ""} -- stim guide lifecycle concurrency`);
+		waitingOn(holder.projectRoot || null);
+		let waited;
+		try {
+			const ceilingMs = WAIT_CEILING_MS - (now() - waitStarted);
+			if (ceilingMs <= 0) throw Object.assign(/* @__PURE__ */ new Error(`Waited ${formatDuration(now() - waitStarted)} for shared builds without an artifact; ${who} (pid ${holder.pid}) holds ${attempt.path}.`), {
+				code: "STIM_BUILD_WAIT_TIMEOUT",
+				lockPath: attempt.path
+			});
+			waited = await wait({
+				platform,
+				key,
+				out,
+				ceilingMs
+			});
+		} catch (err) {
+			const refusal = (0, ownership_claim_exports.claimFailure)(err, command);
+			if (refusal) return { refusal };
+			const timeout = err;
+			if (timeout?.code !== "STIM_BUILD_WAIT_TIMEOUT") throw err;
+			return { refusal: {
+				code: "STIM_BUILD_WAIT_TIMEOUT",
+				message: timeout.message,
+				remedy: `Check pid ${holder.pid}; if it is not really building, remove ${timeout.lockPath} and run \`${command}\` again.`
+			} };
+		}
+		if (waited.hit) {
+			waitingOn(null);
+			phase(`waited ${formatDuration(waited.waitedMs)} for ${who}'s build -> installed from cache -- stim guide lifecycle concurrency`);
+			return {
+				refusal: null,
+				lock: null,
+				hit: {
+					path: waited.hit,
+					waited: {
+						pid: holder.pid,
+						ms: waited.waitedMs
+					}
+				},
+				released
+			};
+		}
+		if (waited.lockReleased) {
+			failedHolder = void 0;
+			released = {
+				facts: {
+					pid: holder.pid,
+					ms: waited.waitedMs
+				},
+				who
+			};
+			phase(`${who}'s build lock was released; rechecking this workspace before building`);
+		} else {
+			warn(`${who}'s build ended without an artifact (${waited.builderFailed}); retrying the build lock`);
+			failedHolder = holder;
+		}
+	}
+}
+const DEFAULT_LEASE_MS = 3e5;
+const LEASE_SUFFIX = ".json";
+const LOCK_SUFFIX = ".lock";
+const DURATION = /^[1-9][0-9]*(s|m)$/;
+function deviceLocksDir() {
+	return join(getConfigDir(), "device-locks");
+}
+function leaseStem(platform, id) {
+	return `${segment(platform)}-${segment(id)}`;
+}
+function deviceLeasePath(platform, id) {
+	return join(deviceLocksDir(), `${leaseStem(platform, id)}${LEASE_SUFFIX}`);
+}
+function deviceLeaseLockPath(platform, id) {
+	return join(deviceLocksDir(), `${leaseStem(platform, id)}${LOCK_SUFFIX}`);
+}
+const fileLeaseIo = {
+	withHolderLock: withWorkspaceStateLock,
+	now: () => Date.now(),
+	readLease(path) {
+		try {
+			return readFileSync(path, "utf-8");
+		} catch {
+			return null;
+		}
+	},
+	writeLease(path, body) {
+		mkdirSync(deviceLocksDir(), { recursive: true });
+		const tmp = `${path}.tmp-${process.pid}-${randomBytes(4).toString("hex")}`;
+		writeFileSync(tmp, body);
+		try {
+			renameSync(tmp, path);
+		} catch (error) {
+			rmSync(tmp, { force: true });
+			throw error;
+		}
+	},
+	removeLease(path) {
+		rmSync(path, { force: true });
+	},
+	listLeaseNames() {
+		try {
+			return readdirSync(deviceLocksDir());
+		} catch {
+			return [];
+		}
+	},
+	withLeaseLock(lockPath, fn) {
+		return withDirLock$1(lockPath, fn, { ensureParent: () => mkdirSync(deviceLocksDir(), { recursive: true }) });
+	},
+	readHolder(root) {
+		return parseWorkspaceLeases(readWorkspaceState$1(root)?.deviceLeases);
+	},
+	writeHolder(root, leases) {
+		if (Object.keys(leases).length === 0) clearWorkspaceStateKeys(root, ["deviceLeases"]);
+		else writeWorkspaceState(root, { deviceLeases: leases });
+	}
+};
+function text(value) {
+	return typeof value === "string" && value.trim() !== "" ? value : null;
+}
+function isPlatform(value) {
+	return value === "ios" || value === "android";
+}
+function parseLease(raw) {
+	if (typeof raw !== "string") return null;
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		return null;
+	}
+	if (!isJsonObject(parsed)) return null;
+	const entry = parsed;
+	if (entry.version !== 1 || !isPlatform(entry.platform)) return null;
+	const id = text(entry.id);
+	const holder = text(entry.holder);
+	const token = text(entry.token);
+	const expiresAt = text(entry.expiresAt);
+	if (!id || !holder || !token || !expiresAt || !Number.isFinite(Date.parse(expiresAt))) return null;
+	if (entry.slot !== void 0) {
+		if (typeof entry.slot !== "string") return null;
+		try {
+			validateDeviceSlot(entry.slot);
+		} catch {
+			return null;
+		}
+	}
+	return {
+		version: 1,
+		...typeof entry.slot === "string" ? { slot: entry.slot } : {},
+		platform: entry.platform,
+		id,
+		deviceName: text(entry.deviceName),
+		holder,
+		token,
+		grantedAt: text(entry.grantedAt),
+		expiresAt
+	};
+}
+function parseWorkspaceLeases(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+	const leases = {};
+	for (const [platform, entry] of Object.entries(value)) {
+		if (!parseDeviceSlotKey(platform) || !entry || typeof entry !== "object") continue;
+		const record = entry;
+		const id = text(record.id);
+		const token = text(record.token);
+		if (!id || !token) continue;
+		leases[platform] = {
+			id,
+			token,
+			kind: record.kind === "run" ? "run" : "declared"
+		};
+	}
+	return leases;
+}
+function leaseIsExpired(lease, now) {
+	return Date.parse(lease.expiresAt) <= now;
+}
+function parseLeaseDuration(value) {
+	const raw = String(value ?? "").trim();
+	const match = DURATION.exec(raw);
+	if (!match) return { error: `--for must be a whole number of seconds or minutes, such as 90s or 5m (got "${raw}").` };
+	const ms = Number(raw.slice(0, -1)) * (match[1] === "s" ? 1e3 : 6e4);
+	if (ms < 1e4 || ms > 18e5) return { error: `--for must be between 10s and 30m (got "${raw}").` };
+	return { ms };
+}
+function listLeaseFiles(io = fileLeaseIo) {
+	const dir = deviceLocksDir();
+	const entries = [];
+	for (const name of io.listLeaseNames().toSorted()) {
+		if (!name.endsWith(LEASE_SUFFIX)) continue;
+		const path = join(dir, name);
+		const lease = parseLease(io.readLease(path));
+		const stem = name.slice(0, -5);
+		const cut = stem.indexOf("-");
+		entries.push({
+			path,
+			name,
+			platform: lease?.platform ?? (cut > 0 ? stem.slice(0, cut) : stem),
+			id: lease?.id ?? (cut > 0 ? stem.slice(cut + 1) : null),
+			lease
+		});
+	}
+	return entries;
+}
+function writeLease(lease, io) {
+	io.writeLease(deviceLeasePath(lease.platform, lease.id), `${JSON.stringify(lease, null, 2)}\n`);
+	return lease;
+}
+function takeLease({ root, platform, slot = "default", id, deviceName = null, kind, durationMs = DEFAULT_LEASE_MS }, io = fileLeaseIo) {
+	return withHolderLock(io, root, () => {
+		const key = deviceSlotKey(platform, slot);
+		const previous = io.readHolder(root)[key];
+		if (previous && previous.id !== id) releaseHeld(root, platform, previous, io, slot);
+		for (const entry of listLeaseFiles(io)) {
+			const other = entry.lease;
+			if (!other || other.platform !== platform || other.holder !== root || (other.slot ?? "default") !== slot || other.id === id) continue;
+			releaseByRoot(root, platform, other.id, io);
+		}
+		const declared = previous?.kind === "declared" && previous.id === id;
+		const path = deviceLeasePath(platform, id);
+		const result = io.withLeaseLock(deviceLeaseLockPath(platform, id), () => {
+			const now = io.now();
+			const raw = io.readLease(path);
+			const current = parseLease(raw);
+			if (raw !== null && !current) return {
+				status: "unreadable",
+				path
+			};
+			const asked = now + durationMs;
+			if (current && !leaseIsExpired(current, now)) {
+				if (current.holder !== root || (current.slot ?? "default") !== slot) return {
+					status: "held",
+					lease: current
+				};
+				const floor = declared && kind === "run" ? Math.max(asked, Date.parse(current.expiresAt)) : asked;
+				return {
+					status: "set",
+					lease: writeLease({
+						...current,
+						deviceName: deviceName ?? current.deviceName,
+						expiresAt: new Date(floor).toISOString()
+					}, io)
+				};
+			}
+			const expiresAt = new Date(asked).toISOString();
+			return {
+				status: "taken",
+				lease: writeLease({
+					version: 1,
+					...slot === "default" ? {} : { slot },
+					platform,
+					id,
+					deviceName,
+					holder: root,
+					token: randomBytes(12).toString("hex"),
+					grantedAt: new Date(now).toISOString(),
+					expiresAt
+				}, io)
+			};
+		});
+		if (result.status === "taken" || result.status === "set") {
+			const recorded = result.status === "set" && declared ? "declared" : kind;
+			io.writeHolder(root, {
+				...io.readHolder(root),
+				[key]: {
+					id,
+					token: result.lease.token,
+					kind: recorded
+				}
+			});
+		}
+		return result;
+	});
+}
+function raiseLease({ root, platform, slot = "default", minMs }, io = fileLeaseIo) {
+	const record = io.readHolder(root)[deviceSlotKey(platform, slot)];
+	if (!record) return { status: "none" };
+	const path = deviceLeasePath(platform, record.id);
+	return io.withLeaseLock(deviceLeaseLockPath(platform, record.id), () => {
+		const current = parseLease(io.readLease(path));
+		if (!current || current.token !== record.token) return {
+			status: "lost",
+			lease: current
+		};
+		const floor = io.now() + minMs;
+		if (Date.parse(current.expiresAt) >= floor) return {
+			status: "raised",
+			lease: current
+		};
+		return {
+			status: "raised",
+			lease: writeLease({
+				...current,
+				expiresAt: new Date(floor).toISOString()
+			}, io)
+		};
+	});
+}
+function summarize(lease) {
+	return {
+		platform: lease.platform,
+		id: lease.id,
+		deviceName: lease.deviceName,
+		expiresAt: lease.expiresAt
+	};
+}
+function releaseHeld(root, platform, record, io, slot = "default") {
+	const key = deviceSlotKey(platform, slot);
+	const path = deviceLeasePath(platform, record.id);
+	const released = io.withLeaseLock(deviceLeaseLockPath(platform, record.id), () => {
+		const current = parseLease(io.readLease(path));
+		if (!current || current.token !== record.token) return null;
+		io.removeLease(path);
+		return current;
+	});
+	const held = io.readHolder(root);
+	if (held[key]?.token === record.token) {
+		delete held[key];
+		io.writeHolder(root, held);
+	}
+	return released;
+}
+function releaseByRoot(root, platform, id, io) {
+	const path = deviceLeasePath(platform, id);
+	return io.withLeaseLock(deviceLeaseLockPath(platform, id), () => {
+		const current = parseLease(io.readLease(path));
+		if (!current || current.holder !== root) return null;
+		io.removeLease(path);
+		return current;
+	});
+}
+function releaseRunLease({ root, platform, slot = "default" }, io = fileLeaseIo) {
+	return withHolderLock(io, root, () => {
+		const record = io.readHolder(root)[deviceSlotKey(platform, slot)];
+		if (!record || record.kind !== "run") return null;
+		const released = releaseHeld(root, platform, record, io, slot);
+		return released ? summarize(released) : null;
+	});
+}
+function releaseWorkspaceLeases(root, { platform = null, slot = null } = {}, io = fileLeaseIo) {
+	return withHolderLock(io, root, () => {
+		const released = [];
+		for (const [name, record] of Object.entries(io.readHolder(root))) {
+			const parsed = parseDeviceSlotKey(name);
+			if (!parsed || platform && parsed.platform !== platform || slot !== null && parsed.slot !== slot) continue;
+			const lease = releaseHeld(root, parsed.platform, record, io, parsed.slot);
+			if (lease) released.push(summarize(lease));
+		}
+		for (const entry of listLeaseFiles(io)) {
+			const lease = entry.lease;
+			if (!lease || lease.holder !== root) continue;
+			if (platform && lease.platform !== platform) continue;
+			if (slot !== null && (lease.slot ?? "default") !== slot) continue;
+			const byRoot = releaseByRoot(root, lease.platform, lease.id, io);
+			if (byRoot) released.push(summarize(byRoot));
+		}
+		return released;
+	});
+}
+/** Releases workspace leases with asynchronous lock waits and the same ownership checks. */
+async function releaseWorkspaceLeasesAsync(root, options = {}) {
+	const released = [];
+	const lockOptions = { ensureParent: () => mkdirSync(deviceLocksDir(), { recursive: true }) };
+	for (;;) {
+		const attempt = {};
+		const io = {
+			...fileLeaseIo,
+			removeLease(path) {
+				const lease = parseLease(fileLeaseIo.readLease(path));
+				fileLeaseIo.removeLease(path);
+				if (lease) released.push(summarize(lease));
+			},
+			withLeaseLock(path, fn) {
+				try {
+					return withDirLock$1(path, fn, {
+						...lockOptions,
+						waitMs: 0
+					});
+				} catch (error) {
+					if (error instanceof Error && "code" in error && error.code === "STIM_LOCK_TIMEOUT") attempt.blocked = {
+						path,
+						error
+					};
+					throw error;
+				}
+			}
+		};
+		await withWorkspaceStateLockAsync(root, () => {
+			try {
+				releaseWorkspaceLeases(root, options, io);
+			} catch (error) {
+				if (error !== attempt.blocked?.error) throw error;
+			}
+		});
+		const blocked = attempt.blocked;
+		if (!blocked) return released;
+		await withDirLockAsync$1(blocked.path, () => void 0, lockOptions);
+	}
+}
+function removeExpiredLease(entry, io = fileLeaseIo) {
+	const lease = entry.lease;
+	if (!lease) return false;
+	return io.withLeaseLock(deviceLeaseLockPath(lease.platform, lease.id), () => {
+		const current = parseLease(io.readLease(entry.path));
+		if (!current || !leaseIsExpired(current, io.now())) return false;
+		io.removeLease(entry.path);
+		return true;
+	});
+}
+function selectPoolDevice({ candidates, leases, held = null, now }) {
+	const ordered = candidates.toSorted((a, b) => {
+		const left = a.id.toLowerCase();
+		const right = b.id.toLowerCase();
+		return left < right ? -1 : left > right ? 1 : 0;
+	});
+	if (held) {
+		const mine = ordered.find((candidate) => candidate.id === held);
+		return mine ? {
+			status: "selected",
+			candidate: mine
+		} : {
+			status: "held-disconnected",
+			id: held
+		};
+	}
+	const preferred = ordered.filter((candidate) => !candidate.fallback);
+	const pool = preferred.length > 0 ? preferred : ordered;
+	if (pool.length === 0) return { status: "none" };
+	const byId = new Map(leases.map((lease) => [lease.id, lease]));
+	const free = (candidate) => {
+		const lease = byId.get(candidate.id);
+		return !lease || leaseIsExpired(lease, now);
+	};
+	const holders = [];
+	for (const candidate of pool) {
+		if (free(candidate)) return {
+			status: "selected",
+			candidate
+		};
+		const lease = byId.get(candidate.id);
+		holders.push({
+			id: lease.id,
+			holder: lease.holder,
+			expiresAt: lease.expiresAt
+		});
+	}
+	return {
+		status: "busy",
+		holders,
+		spare: ordered.filter((candidate) => candidate.fallback && free(candidate)).map((candidate) => candidate.id)
+	};
+}
+function withHolderLock(io, root, fn) {
+	return io.withHolderLock ? io.withHolderLock(root, fn) : fn();
+}
+//#endregion
+//#region src/devices/activity.ts
+const ACTIVE_WINDOW_MS = 6e5;
+const LOG_TAIL_BYTES = 262144;
+function classifyActivity(evidence, now) {
+	const last = evidence.recency.reduce((best, entry) => Number.isFinite(entry.at) && (!best || entry.at > best.at) ? entry : best, null);
+	const recent = {};
+	for (const { basis, at } of evidence.recency) if (Number.isFinite(at) && !(Date.parse(recent[basis] ?? "") >= at)) recent[basis] = new Date(at).toISOString();
+	const lastActivityAt = last ? {
+		lastActivityAt: new Date(last.at).toISOString(),
+		recent
+	} : {};
+	const [first] = evidence.drivers;
+	if (first) {
+		const { basis: _basis, ...driver } = first;
+		return {
+			state: "driven",
+			driver,
+			...lastActivityAt,
+			basis: [...new Set(evidence.drivers.map((entry) => entry.basis))]
+		};
+	}
+	if (evidence.unknown.length) return {
+		state: "unknown",
+		...lastActivityAt,
+		basis: [...new Set(evidence.unknown)]
+	};
+	return {
+		state: Boolean(last && now - last.at < ACTIVE_WINDOW_MS) ? "active" : "idle",
+		...lastActivityAt,
+		basis: [...new Set(evidence.recency.map((entry) => entry.basis))]
+	};
+}
+function idleForMs(activity, now) {
+	if (activity?.state !== "idle" || !activity.lastActivityAt) return null;
+	const at = Date.parse(activity.lastActivityAt);
+	return Number.isFinite(at) ? Math.max(0, now - at) : null;
+}
+function field(entry, pidKey, startKey) {
+	const pid = entry[pidKey];
+	const startTime = entry[startKey];
+	if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0 || typeof startTime !== "string") return null;
+	return {
+		pid,
+		startTime
+	};
+}
+function parseObject(raw) {
+	if (raw === null) return null;
+	try {
+		const parsed = JSON.parse(raw);
+		return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+function parseAgentDeviceRecord(kind, path, raw) {
+	const entry = parseObject(raw);
+	const stem = basename(path, ".json");
+	const device = entry?.device && typeof entry.device === "object" ? entry.device : null;
+	const recordedId = kind === "claim" ? device?.id : entry?.deviceId;
+	const deviceId = typeof recordedId === "string" && recordedId ? recordedId : kind === "runner-lease" ? stem : null;
+	const createdAtMs = typeof entry?.createdAtMs === "number" ? entry.createdAtMs : null;
+	return {
+		path,
+		kind,
+		deviceId,
+		session: kind === "claim" && typeof entry?.session === "string" && entry.session ? entry.session : null,
+		workspace: kind === "claim" && typeof entry?.workspace === "string" && entry.workspace ? entry.workspace : null,
+		stateDir: kind === "claim" && typeof entry?.stateDir === "string" && entry.stateDir ? entry.stateDir : null,
+		deviceName: kind === "claim" && typeof device?.name === "string" ? device.name : null,
+		readable: Boolean(entry && deviceId),
+		owner: entry ? field(entry, "ownerPid", "ownerStartTime") : null,
+		runner: entry && kind === "runner-lease" ? field(entry, "runnerPid", "runnerStartTime") : null,
+		claimProtocol: kind === "runner-lease" && entry?.deviceClaimProtocol === 1,
+		createdAtMs,
+		xctestrunPath: typeof entry?.xctestrunPath === "string" ? entry.xctestrunPath : null
+	};
+}
+function processMatches(entry, startOf) {
+	const start = startOf(entry.pid);
+	if (start.status === "gone") return "dead";
+	if (start.status === "unknown") return "unknown";
+	const recorded = Date.parse(entry.startTime);
+	if (!Number.isFinite(recorded)) return "unknown";
+	return Math.floor(start.startedAtMs / 1e3) === Math.floor(recorded / 1e3) ? "live" : "dead";
+}
+function agentDeviceDaemon(stateDir, startOf = process_identity_exports.inspectProcessStart) {
+	let raw;
+	try {
+		raw = readFileSync(join(stateDir, "daemon.json"), "utf8");
+	} catch (error) {
+		return error.code === "ENOENT" ? "none" : "unknown";
+	}
+	const entry = parseObject(raw);
+	const owner = entry && field(entry, "pid", "processStartTime");
+	return owner ? processMatches(owner, startOf) : "unknown";
+}
+function agentDeviceLiveness(record, startOf) {
+	const results = (record.kind === "claim" ? [record.owner] : [record.owner, record.runner]).map((entry) => entry ? processMatches(entry, startOf) : "unknown");
+	if (results.includes("dead")) return "dead";
+	if (!record.readable || results.includes("unknown")) return "unknown";
+	return "live";
+}
+const HOST_PROCESS_COLUMNS = "pid=,ppid=,rss=,%cpu=,lstart=,command=";
+function parseProcessTable(output) {
+	const rows = [];
+	for (const line of output.split("\n")) {
+		const match = /^\s*(\d+)\s+(\d+)\s+(\d+)\s+(\d+(?:[.,]\d+)?)\s+(\w{3}\s+\w{3}\s+\d+\s+\d{1,2}:\d{2}:\d{2}\s+\d{4})\s+(.*)$/.exec(line);
+		if (!match) continue;
+		const at = Date.parse(match[5]);
+		rows.push({
+			pid: Number(match[1]),
+			ppid: Number(match[2]),
+			rssKb: Number(match[3]),
+			cpuPercent: Number(match[4].replace(",", ".")),
+			startedAt: Number.isFinite(at) ? new Date(at).toISOString() : null,
+			command: match[6]
+		});
+	}
+	return rows;
+}
+function parseAndroidInstrumentation(output) {
+	const found = [];
+	for (const line of output.split("\n")) {
+		const match = /^\s*(\d+)\s+(.*)$/.exec(line);
+		if (!match) continue;
+		const tool = instrumentationTool(match[2]);
+		if (tool) found.push({
+			pid: Number(match[1]),
+			tool
+		});
+	}
+	return found;
+}
+function latestDeviceLogAt(lines, target) {
+	return latestRecordAt(lines, (record) => {
+		if (record.src !== "device" || record.platform !== target.platform || !isDeviceRecord(record)) return false;
+		if (target.slot === "default") return record.slot === void 0;
+		return record.slot === target.slot && (record.deviceId === void 0 || record.deviceId === target.id);
+	});
+}
+function latestBundleRequestAt(lines, platform) {
+	return latestRecordAt(lines, (record) => record.event === "bundle_response_started" && record.platform === platform);
+}
+function latestRecordAt(lines, matches) {
+	for (let i = lines.length - 1; i >= 0; i--) {
+		const record = parseObject(lines[i]);
+		if (record && typeof record.ts === "number" && matches(record)) return record.ts;
+	}
+	return null;
+}
+function isDeviceRecord(record) {
+	return !(typeof record.event === "string" && record.event.startsWith("collector_"));
+}
+/** The last lines of the file at `path`, at most its final 256 KiB, or null when it cannot be read. */
+function tailLines(path) {
+	let fd;
+	try {
+		fd = openSync(path, "r");
+		const size = fstatSync(fd).size;
+		const length = Math.min(size, LOG_TAIL_BYTES);
+		const buffer = Buffer.alloc(length);
+		readSync(fd, buffer, 0, length, size - length);
+		const lines = buffer.toString("utf8").split("\n");
+		return length < size ? lines.slice(1) : lines;
+	} catch {
+		return null;
+	} finally {
+		if (fd !== void 0) closeSync(fd);
+	}
+}
+function envDir(name, env = process.env, cwd = process.cwd()) {
+	const value = env[name]?.trim();
+	return value ? resolve(cwd, value) : null;
+}
+function agentDeviceDirs(home, env = process.env) {
+	const root = join(home, ".agent-device");
+	const leaseDirs = [envDir("AGENT_DEVICE_IOS_RUNNER_LEASE_DIR", env) ?? join(root, "apple-runner", "leases"), join(root, "ios-runner", "leases")];
+	return [{
+		kind: "claim",
+		dir: envDir("AGENT_DEVICE_CLAIMS_DIR", env) ?? join(root, "device-claims")
+	}, ...[...new Set(leaseDirs)].map((dir) => ({
+		kind: "runner-lease",
+		dir
+	}))];
+}
+/**
+* When an agent-device session last recorded an event: its events file's modification time. agent-device names a
+* session's directory after the session with every character outside `[a-zA-Z0-9._-]` replaced by `_`.
+*/
+function agentSessionActedAt(home, session, stateDir, env = process.env) {
+	let latest = null;
+	for (const root of stateDir ? [stateDir] : agentDeviceStateDirs(home, env)) try {
+		const at = statSync(join(root, "sessions", session.replaceAll(/[^a-zA-Z0-9._-]/g, "_"), "events.ndjson")).mtimeMs;
+		latest = latest === null ? at : Math.max(latest, at);
+	} catch {}
+	return latest;
+}
+function readAgentDeviceRecords(home, env = process.env) {
+	return agentDeviceDirs(home, env).flatMap(({ kind, dir }) => {
+		let names;
+		try {
+			names = readdirSync(dir).filter((name) => name.endsWith(".json"));
+		} catch {
+			return [];
+		}
+		return names.map((name) => {
+			const path = join(dir, name);
+			let raw = null;
+			try {
+				raw = readFileSync(path, "utf8");
+			} catch {}
+			return parseAgentDeviceRecord(kind, path, raw);
+		});
+	});
+}
+async function readAgentDeviceRecordsAsync(home, env = process.env) {
+	const records = [];
+	for (const { kind, dir } of agentDeviceDirs(home, env)) {
+		let names;
+		try {
+			names = (await readdir(dir)).filter((name) => name.endsWith(".json"));
+		} catch {
+			continue;
+		}
+		for (const name of names) {
+			const path = join(dir, name);
+			let raw = null;
+			try {
+				raw = await readFile(path, "utf8");
+			} catch {}
+			records.push(parseAgentDeviceRecord(kind, path, raw));
+		}
+	}
+	return records;
+}
+function isClaimProtocolRunner(record, row) {
+	if (!record.claimProtocol || record.runner?.pid !== row.pid || row.startedAt === null) return false;
+	const recorded = Date.parse(record.runner.startTime);
+	return Math.floor(recorded / 1e3) === Math.floor(Date.parse(row.startedAt) / 1e3);
+}
+function lsofArgs(port) {
+	return [
+		"-nP",
+		`-iTCP:${port}`,
+		"-sTCP:ESTABLISHED",
+		"-Fpn"
+	];
+}
+function lsofNoMatch(error) {
+	const stdout = error.stdout;
+	return error.status === 1 && (stdout === "" || stdout === void 0) ? "" : null;
+}
+function createDeviceProcessTables() {
+	const exec = getExecutor();
+	let host;
+	const android = /* @__PURE__ */ new Map();
+	const tcp = /* @__PURE__ */ new Map();
+	return {
+		tcpConnections(port) {
+			if (!tcp.has(port)) {
+				let output;
+				try {
+					output = exec.runFile("lsof", lsofArgs(port), { timeoutMs: 5e3 });
+				} catch (error) {
+					output = lsofNoMatch(error);
+				}
+				tcp.set(port, output);
+			}
+			return tcp.get(port) ?? null;
+		},
+		host() {
+			if (host === void 0) {
+				const output = exec.runFileQuiet("ps", [
+					"-axww",
+					"-o",
+					HOST_PROCESS_COLUMNS
+				], { timeoutMs: 1e4 });
+				host = output === null ? null : parseProcessTable(output);
+			}
+			return host;
+		},
+		android(serial) {
+			if (!android.has(serial)) android.set(serial, exec.runFileQuiet("adb", [
+				"-s",
+				serial,
+				"shell",
+				"ps",
+				"-A",
+				"-o",
+				"PID,ARGS"
+			], { timeoutMs: 5e3 }));
+			return android.get(serial) ?? null;
+		}
+	};
+}
+async function readHostProcessTableAsync(signal, operation) {
+	const output = await runOperationFileQuiet(operation, getExecutor(), "ps", [
+		"-axww",
+		"-o",
+		HOST_PROCESS_COLUMNS
+	], {
+		timeoutMs: 1e4,
+		killSignal: "SIGKILL",
+		signal,
+		cwd: operation?.cwd
+	});
+	return output === null ? null : parseProcessTable(output);
+}
+/** Reads bounded host/instrumentation children asynchronously, sharing observations across device targets. */
+function createActivityReaderAsync(options = {}) {
+	const exec = getExecutor();
+	let host;
+	let hostValue = null;
+	const android = /* @__PURE__ */ new Map();
+	const androidValues = /* @__PURE__ */ new Map();
+	const read = createActivityReader({
+		...options,
+		tables: {
+			...createDeviceProcessTables(),
+			host: () => hostValue,
+			android: (serial) => androidValues.get(serial) ?? null
+		}
+	});
+	const probe = async (target) => {
+		options.signal?.throwIfAborted();
+		host ??= readHostProcessTableAsync(options.signal, options.operation);
+		hostValue = await host;
+		options.signal?.throwIfAborted();
+		if (target.platform === "android") {
+			let pending = android.get(target.id);
+			if (!pending) {
+				pending = runOperationFileQuiet(options.operation, exec, "adb", [
+					"-s",
+					target.id,
+					"shell",
+					"ps",
+					"-A",
+					"-o",
+					"PID,ARGS"
+				], {
+					timeoutMs: 5e3,
+					killSignal: "SIGKILL",
+					signal: options.signal,
+					cwd: process.platform === "win32" ? homedir() : options.operation?.cwd
+				});
+				android.set(target.id, pending);
+			}
+			androidValues.set(target.id, await pending);
+		}
+		options.signal?.throwIfAborted();
+		return read(target);
+	};
+	let queued = Promise.resolve();
+	return (target) => {
+		if (!options.operation) return probe(target);
+		const result = queued.then(() => probe(target));
+		queued = result;
+		return result;
+	};
+}
+function workspaceDeviceRecency(root) {
+	const recency = [];
+	const usedAt = Date.parse(String(readWorkspaceState$1(root)?.lastUsedAt ?? ""));
+	if (Number.isFinite(usedAt)) recency.push({
+		basis: "workspace-use",
+		at: usedAt
+	});
+	for (const file of ["client.ndjson", "device.ndjson"]) try {
+		recency.push({
+			basis: "device-log",
+			at: statSync(join(workspaceLogsDir$1(root), file)).mtimeMs
+		});
+	} catch {}
+	return recency;
+}
+/** The newest workspace use or change to its in-app or native device logs. */
+function workspaceDeviceLastUseAt(root) {
+	const times = workspaceDeviceRecency(root).map(({ at }) => at).filter(Number.isFinite);
+	return times.length ? Math.max(...times) : NaN;
+}
+function createActivityReader({ now = Date.now(), env = process.env, home = env.HOME || env.USERPROFILE || homedir(), startOf = process_identity_exports.inspectProcessStart, leaseFiles = listLeaseFiles, tables = createDeviceProcessTables(), viewers = readViewedDevices } = {}) {
+	let agentDevice;
+	let stimLeases;
+	let viewed;
+	const logs = /* @__PURE__ */ new Map();
+	const log = (path) => {
+		if (!logs.has(path)) logs.set(path, tailLines(path));
+		return logs.get(path) ?? null;
+	};
+	return (target) => {
+		const evidence = {
+			drivers: [],
+			unknown: [],
+			recency: []
+		};
+		agentDevice ??= readAgentDeviceRecords(home, env).map((record) => ({
+			record,
+			liveness: agentDeviceLiveness(record, startOf)
+		}));
+		for (const { record, liveness } of agentDevice) {
+			if (record.deviceId !== null && record.deviceId !== target.id) continue;
+			if (record.claimProtocol) continue;
+			const basis = record.kind === "claim" ? "agent-device-claim" : "agent-device-lease";
+			if (liveness === "live") {
+				evidence.drivers.push({
+					basis,
+					tool: "agent-device",
+					pid: record.owner?.pid ?? null,
+					since: record.createdAtMs !== null ? new Date(record.createdAtMs).toISOString() : null
+				});
+				const actedAt = record.session ? agentSessionActedAt(home, record.session, record.stateDir, env) : null;
+				if (actedAt !== null) evidence.recency.push({
+					basis: "agent-action",
+					at: actedAt
+				});
+			} else if (liveness === "unknown") evidence.unknown.push(basis);
+		}
+		try {
+			stimLeases ??= leaseFiles();
+		} catch {
+			stimLeases = [];
+			evidence.unknown.push("device-lock");
+		}
+		for (const entry of stimLeases) {
+			if (entry.platform !== target.platform || entry.id !== target.id) continue;
+			if (!entry.lease) evidence.unknown.push("device-lock");
+			else if (!leaseIsExpired(entry.lease, now)) evidence.drivers.push({
+				basis: "device-lock",
+				tool: "stim device lock",
+				pid: null,
+				since: entry.lease.grantedAt
+			});
+		}
+		viewed ??= viewers();
+		if (viewed.some((device) => device.platform === target.platform && device.id === target.id)) evidence.recency.push({
+			basis: "viewer",
+			at: now
+		});
+		const processes = tables.host();
+		if (processes === null) evidence.unknown.push("driver-process");
+		for (const row of processes ?? []) {
+			if (agentDevice.some(({ record }) => isClaimProtocolRunner(record, row))) continue;
+			const tool = hostDriverTool(row.command, target.platform, target.id);
+			if (tool) evidence.drivers.push({
+				basis: "driver-process",
+				tool,
+				pid: row.pid,
+				since: row.startedAt
+			});
+		}
+		if (target.platform === "android") {
+			const output = tables.android(target.id);
+			if (output === null) evidence.unknown.push("instrumentation");
+			for (const { pid, tool } of parseAndroidInstrumentation(output ?? "")) evidence.drivers.push({
+				basis: "instrumentation",
+				tool,
+				pid,
+				since: null
+			});
+		}
+		if (target.workspace) {
+			const dir = workspaceLogsDir$1(target.workspace);
+			const deviceAt = latestDeviceLogAt(log(join(dir, "device.ndjson")) ?? [], target);
+			if (deviceAt !== null) evidence.recency.push({
+				basis: "device-log",
+				at: deviceAt
+			});
+			const bundleAt = latestBundleRequestAt(log(join(dir, "metro.ndjson")) ?? [], target.platform);
+			if (bundleAt !== null) evidence.recency.push({
+				basis: "metro-bundle",
+				at: bundleAt
+			});
+			const usedAt = Date.parse(String(readWorkspaceState$1(target.workspace)?.lastUsedAt ?? ""));
+			if (Number.isFinite(usedAt)) evidence.recency.push({
+				basis: "workspace-use",
+				at: usedAt
+			});
+		}
+		return classifyActivity(evidence, now);
+	};
+}
+function workspaceActivity(workspace, now = Date.now()) {
+	const dir = workspaceLogsDir$1(workspace);
+	const state = readWorkspaceState$1(workspace);
+	const recency = [];
+	const deviceAt = latestRecordAt(tailLines(join(dir, "device.ndjson")) ?? [], (record) => record.src === "device" && isDeviceRecord(record));
+	if (deviceAt !== null) recency.push({
+		basis: "device-log",
+		at: deviceAt
+	});
+	const bundleAt = latestRecordAt(tailLines(join(dir, "metro.ndjson")) ?? [], (record) => record.event === "bundle_response_started");
+	if (bundleAt !== null) recency.push({
+		basis: "metro-bundle",
+		at: bundleAt
+	});
+	for (const [basis, value] of [["workspace-use", state?.lastUsedAt], ["supervisor-start", state?.supervisor?.startedAt]]) {
+		const at = Date.parse(String(value ?? ""));
+		if (Number.isFinite(at)) recency.push({
+			basis,
+			at
+		});
+	}
+	return classifyActivity({
+		drivers: [],
+		unknown: [],
+		recency
+	}, now);
+}
+/**
+* The pids of processes connected to loopback `port` as clients, from `lsof -Fpn` output: a connection whose remote
+* end is the port. Chrome's own accepted sockets have the port as their local end and are skipped.
+*/
+function parseTcpClients(output, port) {
+	const pids = /* @__PURE__ */ new Set();
+	let pid = null;
+	for (const line of output.split("\n")) if (line.startsWith("p")) pid = Number(line.slice(1));
+	else if (line.startsWith("n") && pid !== null && Number.isInteger(pid)) {
+		const remote = line.slice(1).split("->")[1];
+		if (remote && Number(remote.slice(remote.lastIndexOf(":") + 1)) === port) pids.add(pid);
+	}
+	return [...pids];
+}
+function webClientPids(connections, target) {
+	return parseTcpClients(connections, target.port).filter((pid) => !target.ownPids.includes(pid));
+}
+function webDrivers(clients, processes) {
+	return clients.flatMap((pid) => {
+		const row = processes.find((candidate) => candidate.pid === pid);
+		const tool = row ? cdpClientTool(row.command) : "unknown DevTools client";
+		return tool ? [{
+			tool,
+			pid,
+			since: row?.startedAt ?? null
+		}] : [];
+	});
+}
+/**
+* The DevTools clients of the owned browser that are not Stim's, read without blocking the event loop; null when
+* lsof or ps could not be read.
+*/
+async function probeWebDrivers(target) {
+	const exec = getExecutor();
+	let connections;
+	try {
+		connections = await exec.runFileAsync("lsof", lsofArgs(target.port), { timeoutMs: 5e3 });
+	} catch (error) {
+		connections = lsofNoMatch(error);
+	}
+	if (connections === null) return null;
+	const clients = webClientPids(connections, target);
+	if (!clients.length) return [];
+	let table;
+	try {
+		table = await exec.runFileAsync("ps", [
+			"-axww",
+			"-o",
+			HOST_PROCESS_COLUMNS
+		], { timeoutMs: 5e3 });
+	} catch {
+		return null;
+	}
+	return webDrivers(clients, parseProcessTable(table));
+}
+/**
+* The owned browser's activity: a DevTools client other than Stim's is a driver (basis `cdp-client`). Recency comes
+* from the newest agent action the browser supervisor recorded (basis `agent-action`) and the newest other page
+* record (basis `page-log`).
+*/
+function readWebActivity(target, tables, now = Date.now()) {
+	const evidence = {
+		drivers: [],
+		unknown: [],
+		recency: []
+	};
+	const connections = tables.tcpConnections(target.port);
+	const clients = connections === null ? [] : webClientPids(connections, target);
+	const processes = clients.length ? (tables.clients ?? tables.host)() : [];
+	if (connections === null || processes === null) evidence.unknown.push("cdp-client");
+	else for (const driver of webDrivers(clients, processes)) evidence.drivers.push({
+		...driver,
+		basis: "cdp-client"
+	});
+	const lines = tailLines(join(workspaceLogsDir$1(target.workspace), "web.ndjson")) ?? [];
+	const actionAt = latestRecordAt(lines, (record) => record.src === "agent");
+	if (actionAt !== null) evidence.recency.push({
+		basis: "agent-action",
+		at: actionAt
+	});
+	const pageAt = latestRecordAt(lines, (record) => record.src !== "agent");
+	if (pageAt !== null) evidence.recency.push({
+		basis: "page-log",
+		at: pageAt
+	});
+	return classifyActivity(evidence, now);
+}
+//#endregion
+export { selectPoolDevice as A, parseLeaseDuration as C, releaseWorkspaceLeases as D, releaseRunLease as E, waitForBuild as F, waitForSharedBuild as I, acquireBuildLock as M, listBuildLocks as N, releaseWorkspaceLeasesAsync as O, releaseBuildLock as P, parseLease as S, raiseLease as T, workspaceDeviceLastUseAt as _, createDeviceProcessTables as a, leaseIsExpired as b, parseAgentDeviceRecord as c, readAgentDeviceRecords as d, readAgentDeviceRecordsAsync as f, workspaceActivity as g, tailLines as h, createActivityReaderAsync as i, takeLease as j, removeExpiredLease as k, probeWebDrivers as l, readWebActivity as m, agentDeviceLiveness as n, envDir as o, readHostProcessTableAsync as p, createActivityReader as r, idleForMs as s, agentDeviceDaemon as t, processMatches as u, deviceLeasePath as v, parseWorkspaceLeases as w, listLeaseFiles as x, fileLeaseIo as y };