stim 1.14.0 → 1.16.0

package/README.md

@@ -43,6 +43,8 @@ reference:
 
 - [Getting started](https://stim.appandflow.com/docs/getting-started): terms,
   the first run, parallel worktrees, and what to do when a run fails.
+- [Native macOS prototype](https://stim.appandflow.com/docs/macos): Swift Package
+  Debug apps, workspace logs and local window viewing in Stim Desktop.
 - [Web in an owned Chrome](https://stim.appandflow.com/docs/web): `stim web`
   for Expo web and other web servers, page logs, and attaching browser tools.
 - [Worktrees](https://stim.appandflow.com/docs/worktrees): `worktree warm`,

package/dist/activity-BxwdD81S.mjs

@@ -0,0 +1,609 @@
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+import { t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
+import { r as readWorkspaceState$1, x as workspaceLogsDir$1 } from "./workspace-state-B8-aJ1_5.mjs";
+import { i as listLeaseFiles, r as leaseIsExpired } from "./device-lease-D-hLqx1b.mjs";
+import { closeSync, fstatSync, openSync, readFileSync, readSync, readdirSync, statSync } from "node:fs";
+import { basename, join, resolve } from "node:path";
+import { agentDeviceStateDirs, readViewedDevices } from "@stim-cli/core/state";
+import { homedir } from "node:os";
+//#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/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) {
+	const value = process.env[name]?.trim();
+	return value ? resolve(value) : null;
+}
+function agentDeviceDirs(home) {
+	const root = join(home, ".agent-device");
+	const leaseDirs = [envDir("AGENT_DEVICE_IOS_RUNNER_LEASE_DIR") ?? join(root, "apple-runner", "leases"), join(root, "ios-runner", "leases")];
+	return [{
+		kind: "claim",
+		dir: envDir("AGENT_DEVICE_CLAIMS_DIR") ?? 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) {
+	let latest = null;
+	for (const root of stateDir ? [stateDir] : agentDeviceStateDirs(home)) 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) {
+	return agentDeviceDirs(home).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);
+		});
+	});
+}
+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;
+		}
+	};
+}
+function createActivityReader({ now = Date.now(), home = 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).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) : 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 { envDir as a, probeWebDrivers as c, readWebActivity as d, tailLines as f, createDeviceProcessTables as i, processMatches as l, agentDeviceLiveness as n, idleForMs as o, workspaceActivity as p, createActivityReader as r, parseAgentDeviceRecord as s, agentDeviceDaemon as t, readAgentDeviceRecords as u };