stim 1.11.0 → 1.13.0

package/dist/{gc-COZteyiq.mjs → gc-eA-PRBX8.mjs}

@@ -1,22 +1,28 @@
-import { A as directorySize, F as volumeRootFor, M as isOnMountedVolume, N as listMountedVolumes, b as removeProject, g as loadConfig, j as formatBytes, k as ownership_claim_exports } from "./config-BEq0Qw_a.mjs";
+import { A as ownership_claim_exports, E as withConfigLock$1, I as volumeRootFor, M as formatBytes, N as isOnMountedVolume, P as listMountedVolumes, U as projectDeviceSlots, _ as loadConfig$1, j as directorySize, k as acquireAvdClaim, p as getProject, x as removeProject } from "./config-0jCcMM0E.mjs";
 import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
-import { N as workspaceStateFile, O as workspaceDir, v as workspaceLastUsed } from "./metro-BWLOJ_Wr.mjs";
-import { C as sourceCheckoutOf, b as resolveFullRef, d as hasUncommittedWork, l as hasPopulatedSubmodules, m as listWorktrees, o as dirtyPaths, w as unpushedCommits } from "./worktree-BlizKDpZ.mjs";
-import { a as detectIsExpo, o as findProjectRoot } from "./project-BXZzOABt.mjs";
-import { h as shortUdid, o as formatLongDuration, u as plural } from "./command-output-D5z2_bcF.mjs";
-import { d as removeExpiredLease, h as listBuildLocks } from "./device-lease-D83nqeMX.mjs";
-import { D as listAvds, N as ownedAvdDirectory, Y as isStimOwnedSim, k as listOrphanedAvdDirectories, w as isStimOwnedAvdName } from "./android-C4zG2Tuc.mjs";
-import { h as POOL_SETTING_REMEDY, y as parkedMaxSetting } from "./ownership-BiojdtAp.mjs";
-import { l as listAllIosSims } from "./ios-DArbmwer.mjs";
-import { a as parseIdleDuration, o as shutDownIdleDevices, r as idleDeviceLines, t as collectIdleDevices } from "./idle-NETbeNiQ.mjs";
-import { i as canonicalPath, o as listBuildSlots, r as workspaceInUse } from "./in-use-DVhlSoyn.mjs";
-import { C as listOwnedSessionsArgs, D as verifyStoppedSession, E as stopSessionArgs, S as isDefinitiveMissingSessionError, T as parseSessionListPage, b as getSessionArgs, d as withRemoteSessionLock, f as withEasProjectLock, h as removeEasSessionClaim, m as readEasSessionLedger, p as easMachineStateRoot, x as inspectSessionForTeardown, y as findOrphanedOwnedSessions, z as resolveEasCliBin } from "./device-remote-BQZSnnmE.mjs";
-import { A as discoverCaches, C as unverifiedDeviceCommand, D as planCacheEmptying, E as includesWorkspaceOutputs, O as selectCaches, S as findStaleProjectDevices, T as emptyCaches, _ as describeParkedSims, a as collectWorkspaceOutputs, b as findOrphanedDevices, c as listWorkspaceDirs, d as collectDeviceLeases, f as collectParkedAvds, g as deleteProjectDevices, h as deleteParkedSims, i as collectOrphanedWorkspaces, j as sizeCaches, k as trimCaches, l as sizeText, m as deleteParkedAvds, n as WORKSPACE_OUTPUT_DIRS, o as deleteOrphanedWorkspaces, p as collectParkedSims, r as clearWorkspaceOutputs, s as isInsideWorkspaces, t as REBUILD_COST, u as DEVICE_LIST_TIMEOUT_MS, v as describeUnverifiableDevices, w as withAndroidAvdSizes, x as findStaleDeviceRecords, y as deviceSweepIsScoped } from "./workspaces-COD2xCz-.mjs";
-import { a as reclaimKeys, d as removeWorktreeTarget, m as reclaimProject, n as excludePodChurn, p as describeDereferenced, r as matchWorktreeEntry } from "./worktree-KOjMX3zA.mjs";
-import { n as mergeState, t as fetchDefaultBranch } from "./merge-state-DDxS-XIZ.mjs";
+import { F as withDirLock, M as workspaceLogsDir, P as workspaceStateFile, k as workspaceDir, y as workspaceLastUsed } from "./metro-BPeY1YMh.mjs";
+import { C as sourceCheckoutOf, b as resolveFullRef, d as hasUncommittedWork, l as hasPopulatedSubmodules, m as listWorktrees, o as dirtyPaths, w as unpushedCommits } from "./worktree-DeBQSVtR.mjs";
+import { a as findProjectRoot, r as detectIsExpo } from "./project-DGeclhvO.mjs";
+import { h as shortUdid, o as formatLongDuration, u as plural } from "./command-output-BIL7rlX7.mjs";
+import { d as removeExpiredLease, h as listBuildLocks, i as listLeaseFiles, r as leaseIsExpired } from "./device-lease-CL9dZf73.mjs";
+import { A as listInstalledSystemImages, B as parseAvdDeviceProfile, F as ownedAvdDirectory, R as ownedAvdSerialResolver, V as parseAvdSystemImage, a as androidHome, ct as parkedMaxSetting, f as avdIniPaths, g as avdStorageRoots, j as listOrphanedAvdDirectories, k as listAvds, lt as readParked, nt as isStimOwnedSim, p as avdNameAbsent, rt as POOL_SETTING_REMEDY, tt as isStimOwnedAvd, u as androidToolPath } from "./android-qx_31wJo.mjs";
+import { n as readCreatedDevices$1, t as forgetCreatedDevice } from "./created-devices-Cd558h31.mjs";
+import { l as listAllIosSims } from "./ios-CmEzZiOj.mjs";
+import { a as parseIdleDuration, c as recordGcResult, l as takeGcResults, o as shutDownIdleDevices, r as idleDeviceLines, t as collectIdleDevices } from "./idle-DxLi5OkN.mjs";
+import { i as canonicalPath, n as withIdleWorkspace, o as listBuildSlots, r as workspaceInUse } from "./in-use-wYEaKQM9.mjs";
+import { r as readCollectors } from "./ownership-Bz2kETAS.mjs";
+import { f as resolveEasCliBin } from "./remote-cache--aehr4Pr.mjs";
+import { A as findOrphanedOwnedSessions, C as withEasProjectLock, E as removeEasSessionClaim, I as parseSessionListPage, L as stopSessionArgs, M as inspectSessionForTeardown, N as isDefinitiveMissingSessionError, P as listOwnedSessionsArgs, R as verifyStoppedSession, T as readEasSessionLedger$1, d as withRemoteSessionLock, j as getSessionArgs, w as easMachineStateRoot$1 } from "./device-remote-DT9ngZiD.mjs";
+import { A as includesWorkspaceOutputs, C as deviceSweepIsScoped, D as unverifiedDeviceCommand, E as findStaleProjectDevices, F as sizeCaches, M as selectCaches, N as trimCaches, O as withAndroidAvdSizes, P as discoverCaches, S as describeUnverifiableDevices, T as findStaleDeviceRecords, _ as collectParkedSims, a as REBUILD_COST, b as deleteProjectDevices, c as collectOrphanedWorkspaces, d as isInsideWorkspaces, f as listWorkspaceDirs, g as collectParkedAvds, h as collectDeviceLeases, i as machineNumber, j as planCacheEmptying, k as emptyCaches, l as collectWorkspaceOutputs, m as DEVICE_LIST_TIMEOUT_MS, o as WORKSPACE_OUTPUT_DIRS, p as sizeText, s as clearWorkspaceOutputs, u as deleteOrphanedWorkspaces, v as deleteParkedAvds, w as findOrphanedDevices, x as describeParkedSims, y as deleteParkedSims } from "./budget-E5o91NR1.mjs";
+import { _ as reclaimProject, a as reclaimKeys, d as removeWorktreeTarget, g as describeDereferenced, h as pullRequestLookups, m as endedPullRequest, n as excludePodChurn, p as describePullRequest, r as matchWorktreeEntry } from "./worktree-D4Do_XiQ.mjs";
+import { n as mergeState, t as fetchDefaultBranch } from "./merge-state-ytFQCeh4.mjs";
+import { existsSync, lstatSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { InvalidArgumentError } from "commander";
-import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import { closeSync as closeSync$1, existsSync as existsSync$1, openSync as openSync$1, readFileSync as readFileSync$1, readSync as readSync$1, readdirSync as readdirSync$1, renameSync as renameSync$1, rmSync as rmSync$1, statSync as statSync$1, utimesSync, writeFileSync as writeFileSync$1 } from "fs";
 import { basename, dirname, isAbsolute, join } from "path";
+import { LOG_ROTATE_BYTES, rotatedLogPath } from "@stim-cli/core";
+import { settingDefinition } from "@stim-cli/core/state";
+import { dirname as dirname$1, join as join$1 } from "node:path";
 import chalk from "chalk";
 //#region src/commands/gc/eas-sessions.ts
 const EAS_OPERATION_TIMEOUT_MS = 3e4;
@@ -37,18 +43,18 @@ function readRecordedRemoteSessionIds(roots) {
 	let safe = true;
 	for (const root of new Set(roots)) {
 		try {
-			if (!statSync(root).isDirectory()) throw new Error("path is not a directory");
-			readdirSync(root);
+			if (!statSync$1(root).isDirectory()) throw new Error("path is not a directory");
+			readdirSync$1(root);
 		} catch (error) {
 			safe = false;
 			notices.push(`${root} is not available as a readable workspace directory: ${describeError(error)}`);
 			continue;
 		}
 		const path = workspaceStateFile(root);
-		if (!existsSync(path)) continue;
+		if (!existsSync$1(path)) continue;
 		let state;
 		try {
-			state = JSON.parse(readFileSync(path, "utf-8"));
+			state = JSON.parse(readFileSync$1(path, "utf-8"));
 		} catch (error) {
 			safe = false;
 			notices.push(`${path} could not be read as valid JSON: ${describeError(error)}`);
@@ -84,8 +90,8 @@ function claimStateAbsence(claim) {
 	const stateDir = dirname(claim.stateFile);
 	let entries;
 	try {
-		if (!statSync(stateDir).isDirectory()) throw new Error("path is not a directory");
-		entries = readdirSync(stateDir);
+		if (!statSync$1(stateDir).isDirectory()) throw new Error("path is not a directory");
+		entries = readdirSync$1(stateDir);
 	} catch (error) {
 		return {
 			absent: false,
@@ -98,7 +104,7 @@ function claimStateAbsence(claim) {
 	};
 	let state;
 	try {
-		state = JSON.parse(readFileSync(claim.stateFile, "utf-8"));
+		state = JSON.parse(readFileSync$1(claim.stateFile, "utf-8"));
 	} catch (error) {
 		return {
 			absent: false,
@@ -141,8 +147,8 @@ function collectEasSessionSweep(config, deps) {
 	const eas = (deps.resolveEasCliBin ?? resolveEasCliBin)(projectRoot);
 	if (!eas) return empty(["EAS session sweep skipped: eas-cli is not available for the current Expo project."]);
 	const recorded = readRecordedRemoteSessionIds([...Object.keys(config?.projects ?? {}), projectRoot]);
-	const ledgerRoot = deps.easLedgerRoot ?? easMachineStateRoot();
-	const ledger = readEasSessionLedger(ledgerRoot);
+	const ledgerRoot = deps.easLedgerRoot ?? easMachineStateRoot$1();
+	const ledger = readEasSessionLedger$1(ledgerRoot);
 	const run = deps.runEasFile ?? ((file, args, options) => getExecutor().runFile(file, args, options));
 	const sessions = [];
 	const seenCursors = /* @__PURE__ */ new Set();
@@ -180,7 +186,7 @@ function collectEasSessionSweep(config, deps) {
 	}
 	const lockedRoots = deps.easLockedRoots;
 	if (lockedRoots) {
-		if (easLockRoots(projectRoot, loadConfig()).some((root) => !lockedRoots.includes(root))) return empty([...recorded.notices, "EAS session sweep skipped: registered workspace roots changed after remote-session locks were acquired."]);
+		if (easLockRoots(projectRoot, loadConfig$1()).some((root) => !lockedRoots.includes(root))) return empty([...recorded.notices, "EAS session sweep skipped: registered workspace roots changed after remote-session locks were acquired."]);
 	}
 	const compared = findOrphanedOwnedSessions({
 		sessions,
@@ -215,8 +221,8 @@ function easLockRoots(projectRoot, config) {
 }
 function unavailableLockRootNotice(roots) {
 	for (const root of roots) try {
-		if (!statSync(root).isDirectory()) throw new Error("path is not a directory");
-		readdirSync(root);
+		if (!statSync$1(root).isDirectory()) throw new Error("path is not a directory");
+		readdirSync$1(root);
 	} catch (error) {
 		return `EAS session sweep skipped: ${root} is not available for remote-session lock inspection: ${describeError(error)}`;
 	}
@@ -225,7 +231,7 @@ function unavailableLockRootNotice(roots) {
 function malformedRemoteSessionLockNotice(roots) {
 	for (const root of roots) {
 		const lockPath = join(workspaceDir(root), "remote-session.lock");
-		if (!existsSync(lockPath)) continue;
+		if (!existsSync$1(lockPath)) continue;
 		if ((0, ownership_claim_exports.readClaimSet)(lockPath).unresolved.length === 0) continue;
 		return `EAS session sweep skipped: the remote-session lock at ${lockPath} has a malformed owner record.`;
 	}
@@ -236,7 +242,7 @@ async function withRemoteSessionGcLocks(projectRoot, deps, fn) {
 	const waitMs = deps.easLockWaitMs ?? EAS_LOCK_WAIT_MS;
 	const maxSnapshots = deps.easLockSnapshotRetries ?? EAS_LOCK_SNAPSHOT_RETRIES;
 	for (let attempt = 0; attempt < maxSnapshots; attempt++) {
-		const roots = easLockRoots(projectRoot, loadConfig());
+		const roots = easLockRoots(projectRoot, loadConfig$1());
 		const unavailable = unavailableLockRootNotice(roots);
 		if (unavailable) return fn({
 			...deps,
@@ -250,7 +256,7 @@ async function withRemoteSessionGcLocks(projectRoot, deps, fn) {
 		let expanded = false;
 		let coreStarted = false;
 		const acquire = (index) => index === roots.length ? (async () => {
-			if (easLockRoots(projectRoot, loadConfig()).some((root) => !roots.includes(root))) {
+			if (easLockRoots(projectRoot, loadConfig$1()).some((root) => !roots.includes(root))) {
 				expanded = true;
 				return null;
 			}
@@ -279,6 +285,13 @@ async function withRemoteSessionGcLocks(projectRoot, deps, fn) {
 }
 async function deleteEasSessions(easSessionSweep, deps) {
 	let deleteFailures = 0;
+	const refuseAll = (detail) => {
+		deleteFailures += easSessionSweep.orphaned.length;
+		for (const session of easSessionSweep.orphaned) recordGcResult("easSession", "failed", session.name, {
+			id: session.id,
+			detail
+		});
+	};
 	if (easSessionSweep.orphaned.length && easSessionSweep.deletionSafe && easSessionSweep.projectScope) {
 		const projectScope = easSessionSweep.projectScope;
 		const withProjectLock = deps.withEasProjectLock ?? withEasProjectLock;
@@ -288,17 +301,17 @@ async function deleteEasSessions(easSessionSweep, deps) {
 				finalSweepStarted = true;
 				return withRemoteSessionGcLocks(projectScope, deps, async (lockedDeps) => {
 					if (lockedDeps.easSweepBlockedNotice) {
-						deleteFailures += easSessionSweep.orphaned.length;
+						refuseAll(`EAS session deletion refused: ${lockedDeps.easSweepBlockedNotice}`);
 						console.log(chalk.red(`EAS session deletion refused: ${lockedDeps.easSweepBlockedNotice}`));
 						return;
 					}
 					const coordinatedDeps = lockedDeps;
-					const currentConfig = loadConfig();
+					const currentConfig = loadConfig$1();
 					const currentRoots = easLockRoots(projectScope, currentConfig);
 					const registryExpanded = coordinatedDeps.easLockedRoots && currentRoots.some((root) => !coordinatedDeps.easLockedRoots.includes(root));
 					const currentRecords = registryExpanded ? null : readRecordedRemoteSessionIds([...Object.keys(currentConfig?.projects ?? {}), projectScope]);
-					const ledgerRoot = coordinatedDeps.easLedgerRoot ?? easMachineStateRoot();
-					const ledger = readEasSessionLedger(ledgerRoot);
+					const ledgerRoot = coordinatedDeps.easLedgerRoot ?? easMachineStateRoot$1();
+					const ledger = readEasSessionLedger$1(ledgerRoot);
 					const removeClaim = coordinatedDeps.removeEasSessionClaim ?? removeEasSessionClaim;
 					const reconcileClaim = (sessionId) => {
 						let detail = "the claim store did not remove it";
@@ -311,10 +324,10 @@ async function deleteEasSessions(easSessionSweep, deps) {
 						console.log(chalk.red(`EAS session ${sessionId} is resolved, but its ownership claim could not be removed: ${detail}. The claim was retained for reconciliation.`));
 					};
 					if (registryExpanded) {
-						deleteFailures += easSessionSweep.orphaned.length;
+						refuseAll("EAS session deletion refused: registered workspace roots changed after classification.");
 						console.log(chalk.red("EAS session deletion refused: registered workspace roots changed after classification."));
 					} else if (!currentRecords?.safe || !ledger.safe) {
-						deleteFailures += easSessionSweep.orphaned.length;
+						refuseAll("EAS session deletion refused: the session records could not be read safely.");
 						for (const notice of [...currentRecords?.notices ?? [], ...ledger.notice ? [ledger.notice] : []]) console.log(chalk.red(`EAS session deletion refused: ${notice}`));
 					} else {
 						const recorded = new Set(currentRecords.ids);
@@ -323,6 +336,10 @@ async function deleteEasSessions(easSessionSweep, deps) {
 						for (const session of easSessionSweep.orphaned) {
 							if (recorded.has(session.id)) {
 								console.log(chalk.dim(`EAS session ${session.id} has a workspace record and was left running.`));
+								recordGcResult("easSession", "kept", session.name, {
+									id: session.id,
+									detail: "it has a workspace record and was left running"
+								});
 								continue;
 							}
 							const claim = ledger.claims.get(session.id);
@@ -330,11 +347,19 @@ async function deleteEasSessions(easSessionSweep, deps) {
 							if (!claim || claim.name !== session.name || claim.platform !== session.platform || !claimState?.absent || claimState.notice) {
 								deleteFailures++;
 								console.log(chalk.red(`Could not verify fixed ownership for EAS session ${session.id}: ${claimState?.notice ?? "the claim is missing, mismatched, or still recorded in workspace state"}.`));
+								recordGcResult("easSession", "failed", session.name, {
+									id: session.id,
+									detail: `Could not verify fixed ownership for EAS session ${session.id}: ${claimState?.notice ?? "the claim is missing, mismatched, or still recorded in workspace state"}.`
+								});
 								continue;
 							}
 							if (!eas) {
 								deleteFailures++;
 								console.log(chalk.red(`Could not verify EAS session ${session.id}: eas-cli is not available.`));
+								recordGcResult("easSession", "failed", session.name, {
+									id: session.id,
+									detail: `Could not verify EAS session ${session.id}: eas-cli is not available.`
+								});
 								continue;
 							}
 							const options = {
@@ -352,6 +377,10 @@ async function deleteEasSessions(easSessionSweep, deps) {
 								} else {
 									deleteFailures++;
 									console.log(chalk.red(`Could not verify EAS session ${session.id}: ${describeError(error)}`));
+									recordGcResult("easSession", "failed", session.name, {
+										id: session.id,
+										detail: `Could not verify EAS session ${session.id}: ${describeError(error)}`
+									});
 								}
 								continue;
 							}
@@ -364,6 +393,10 @@ async function deleteEasSessions(easSessionSweep, deps) {
 							if (inspection.action === "refused") {
 								deleteFailures++;
 								console.log(chalk.red(`Could not stop EAS session ${session.id}: ${inspection.reason}`));
+								recordGcResult("easSession", "failed", session.name, {
+									id: session.id,
+									detail: `Could not stop EAS session ${session.id}: ${inspection.reason}`
+								});
 								continue;
 							}
 							let stopped;
@@ -372,15 +405,24 @@ async function deleteEasSessions(easSessionSweep, deps) {
 							} catch (error) {
 								deleteFailures++;
 								console.log(chalk.red(`Could not stop EAS session ${session.id}: ${describeError(error)}`));
+								recordGcResult("easSession", "failed", session.name, {
+									id: session.id,
+									detail: `Could not stop EAS session ${session.id}: ${describeError(error)}`
+								});
 								continue;
 							}
 							const verified = verifyStoppedSession(stopped, session.id);
 							if (!verified.ok) {
 								deleteFailures++;
 								console.log(chalk.red(`Could not verify EAS session ${session.id} stopped: ${verified.reason}`));
+								recordGcResult("easSession", "failed", session.name, {
+									id: session.id,
+									detail: `Could not verify EAS session ${session.id} stopped: ${verified.reason}`
+								});
 								continue;
 							}
 							console.log(chalk.green(`Stopped EAS session ${session.id} (${session.name})`));
+							recordGcResult("easSession", "done", session.name, { id: session.id });
 							reconcileClaim(session.id);
 						}
 					}
@@ -391,8 +433,8 @@ async function deleteEasSessions(easSessionSweep, deps) {
 				machineRoot: deps.easLedgerRoot
 			});
 		} catch (error) {
-			deleteFailures += easSessionSweep.orphaned.length;
 			const phase = finalSweepStarted ? "failed" : "lock acquisition failed";
+			refuseAll(`EAS session deletion ${phase}: ${describeError(error)}`);
 			console.log(chalk.red(`EAS session deletion ${phase}: ${describeError(error)}`));
 		}
 	}
@@ -402,6 +444,8 @@ async function deleteEasSessions(easSessionSweep, deps) {
 //#region src/commands/gc/worktrees.ts
 const DEFAULT_WORKTREE_IDLE_DAYS = 7;
 const DAY_MS = 864e5;
+const MINUTE_MS = 6e4;
+const GRACE_SETTING = "gc.worktreeGraceMinutes";
 const MERGE_DECIDES = /* @__PURE__ */ new Set([
 	"unpushed",
 	"not-merged",
@@ -414,29 +458,77 @@ function skip(code, text) {
 		text
 	};
 }
-function worktreeSkipReason(facts, olderThan) {
+function pullRequestNote(lookup) {
+	const pr = lookup && "pullRequest" in lookup ? lookup.pullRequest : null;
+	if (!pr) return null;
+	return pr.containsHead ? describePullRequest(pr) : `${describePullRequest(pr)}, and HEAD has commits it does not`;
+}
+/**
+* Why gc keeps a worktree, or null when it removes it. A worktree that would be removed is still kept while its last
+* activity, or its merge into the default branch, is less than `grace.ms` old, and kept when that activity is unknown.
+*/
+function worktreeSkipReason(facts, olderThan, grace = {
+	ms: 0,
+	now: 0
+}) {
+	return removalBlocker(facts, olderThan) ?? graceBlocker(facts, grace);
+}
+function graceBlocker(facts, grace) {
+	if (grace.ms <= 0) return null;
+	if (!facts.activity) return skip("activity-unknown", "its last activity could not be read");
+	const merged = facts.merge?.merged ? facts.merge : null;
+	const ended = endedPullRequest(facts.pullRequest);
+	const events = [facts.activity];
+	if (merged) events.push({
+		at: merged.mergedAt,
+		basis: `merged into ${merged.into}`
+	});
+	if (ended?.endedAt) events.push({
+		at: ended.endedAt,
+		basis: describePullRequest(ended)
+	});
+	const latest = events.reduce((a, b) => b.at > a.at ? b : a);
+	const eligibleAt = latest.at + grace.ms;
+	if (grace.now >= eligibleAt) return null;
+	const ago = formatLongDuration(Math.max(0, grace.now - latest.at));
+	return {
+		code: "recent-activity",
+		text: `recent activity: ${latest.basis} ${ago} ago; removable after ${new Date(eligibleAt).toISOString()}`,
+		eligibleAt
+	};
+}
+function removalBlocker(facts, olderThan) {
 	if (facts.bare) return skip("bare-repository", "bare repository");
 	if (typeof facts.source === "object") return skip("source-checkout-unknown", `source checkout unknown: ${facts.source.refusal}`);
 	if (facts.source === "source") return skip("source-checkout", "source checkout");
 	if (facts.locked) return skip("locked", "locked with git worktree lock");
 	if (facts.inUse.length) return skip("in-use", `in use: ${facts.inUse.join("; ")}`);
 	if (facts.porcelain === null) return skip("status-unreadable", "git status could not be read");
-	if (excludePodChurn(facts.porcelain).lines.length) return skip("dirty", "dirty: uncommitted changes or untracked files");
+	const dirty = excludePodChurn(facts.porcelain).lines.length;
+	if (dirty) return skip("dirty", `dirty: ${plural(dirty, "uncommitted or untracked file")}`);
 	if (facts.unpushed === null) return skip("unpushed-unchecked", "unpushed commits could not be checked");
 	const merged = facts.merge?.merged ? facts.merge : null;
-	if (facts.unpushed.length && !merged?.coversUnpushed) return skip("unpushed", `unpushed: ${plural(facts.unpushed.length, "commit")} on no remote or other branch`);
+	const ended = endedPullRequest(facts.pullRequest);
+	if (facts.unpushed.length && !merged?.coversUnpushed && ended?.state !== "merged") return skip("unpushed", `unpushed: ${plural(facts.unpushed.length, "commit")} on no remote or other branch`);
 	if (facts.submodules) return skip("submodules", "initialized submodules");
-	if (merged) return null;
+	if (merged || ended) return null;
 	const notMerged = facts.merge && !facts.merge.merged ? facts.merge : null;
-	if (olderThan === null) return skip(notMerged?.unknown ? "merge-unknown" : "not-merged", notMerged?.detail ?? "not merged");
-	const also = notMerged ? `; ${notMerged.detail}` : "";
+	const details = [notMerged?.detail, pullRequestNote(facts.pullRequest)].filter(Boolean);
+	if (olderThan === null) return skip(notMerged?.unknown ? "merge-unknown" : "not-merged", details.join("; ") || "not merged");
+	const also = details.map((detail) => `; ${detail}`).join("");
 	if (facts.idleDays === null) return skip("last-use-unknown", `recently used: its last use is unknown${also}`);
 	if (facts.idleDays < olderThan) return skip("recently-used", `recently used ${facts.idleDays}d ago${also}`);
 	return null;
 }
-/** Why gc removes a worktree it did not skip: `merged into origin/main` or `idle 9d`. */
+/** Why gc removes a worktree it did not skip: `merged into origin/main`, `PR #12 closed` or `idle 9d`. */
 function worktreeRemovalReason(candidate) {
-	return candidate.merge?.merged ? `merged into ${candidate.merge.into}` : `idle ${candidate.idleDays ?? 0}d`;
+	if (candidate.merge?.merged) return `merged into ${candidate.merge.into}`;
+	const ended = endedPullRequest(candidate.pullRequest);
+	return ended ? describePullRequest(ended) : `idle ${candidate.idleDays ?? 0}d`;
+}
+/** The pull request note a kept worktree's report line carries, such as `PR #12 merged`, or null. */
+function worktreePullRequestNote(candidate) {
+	return pullRequestNote(candidate.pullRequest);
 }
 function lastUsedOf(keys) {
 	const times = keys.map(workspaceLastUsed).filter(Number.isFinite);
@@ -446,8 +538,126 @@ function idleDaysOf(keys, now) {
 	const last = lastUsedOf(keys);
 	return Number.isFinite(last) ? Math.max(0, Math.floor((now - last) / DAY_MS)) : null;
 }
-function inUseOf(keys, checks) {
-	return [...new Set(keys.flatMap((key) => workspaceInUse(key, checks)))];
+function deviceReads() {
+	let sims;
+	let resolver;
+	return {
+		sims: () => {
+			if (sims === void 0) try {
+				sims = listAllIosSims({ timeoutMs: DEVICE_LIST_TIMEOUT_MS });
+			} catch {
+				sims = null;
+			}
+			return sims;
+		},
+		avdSerial: (avdName) => (resolver ??= ownedAvdSerialResolver({ timeoutMs: DEVICE_LIST_TIMEOUT_MS }))(avdName)
+	};
+}
+function inUseOf(keys, checks, devices = deviceReads()) {
+	return [.../* @__PURE__ */ new Set([...keys.flatMap((key) => workspaceInUse(key, checks)), ...deviceUseOf(keys, devices)])];
+}
+function deviceUseOf(keys, devices) {
+	const reasons = [];
+	for (const key of keys) {
+		let slots;
+		try {
+			slots = projectDeviceSlots(getProject(key));
+		} catch (error) {
+			reasons.push(`its device records cannot be read: ${error.message}`);
+			continue;
+		}
+		for (const { platforms } of slots) {
+			const ios = platforms.ios;
+			if (ios?.owned && ios.deviceUdid) {
+				const sims = devices.sims();
+				const sim = sims?.find((entry) => entry.udid === ios.deviceUdid);
+				if (sims === null) reasons.push(`the state of its owned simulator ${ios.deviceUdid} cannot be read`);
+				else if (sim && sim.state !== "Shutdown") reasons.push(`its owned simulator ${sim.name} is ${sim.state}; \`stim stop\` in ${key} shuts it down`);
+			}
+			const android = platforms.android;
+			if (android?.owned && android.avdName) try {
+				if (devices.avdSerial(android.avdName).serial) reasons.push(`its owned emulator ${android.avdName} is running; \`stim stop\` in ${key} shuts it down`);
+			} catch {
+				reasons.push(`the state of its owned emulator ${android.avdName} cannot be read`);
+			}
+		}
+	}
+	const holders = new Set(keys.map(canonicalPath));
+	const now = Date.now();
+	for (const { lease } of listLeaseFiles()) if (lease && !leaseIsExpired(lease, now) && holders.has(canonicalPath(lease.holder))) reasons.push(`it holds the ${lease.platform} device lease on ${lease.deviceName ?? lease.id}`);
+	return reasons;
+}
+function newestMtime(paths) {
+	let newest = null;
+	for (const { path, basis } of paths) {
+		let mtime;
+		try {
+			mtime = statSync$1(path).mtimeMs;
+		} catch (error) {
+			if (error.code === "ENOENT") continue;
+			return "unreadable";
+		}
+		if (!newest || mtime > newest.at) newest = {
+			at: mtime,
+			basis
+		};
+	}
+	return newest;
+}
+function logFiles$1(key) {
+	const dir = workspaceLogsDir(key);
+	try {
+		return readdirSync$1(dir).map((name) => ({
+			path: join(dir, name),
+			basis: "a Stim log write"
+		}));
+	} catch (error) {
+		return error.code === "ENOENT" ? [] : null;
+	}
+}
+function worktreeActivityOf(path, keys) {
+	const gitDir = getExecutor().runFileQuiet("git", [
+		"--no-optional-locks",
+		"-C",
+		path,
+		"rev-parse",
+		"--path-format=absolute",
+		"--git-dir"
+	])?.trim();
+	if (!gitDir) return null;
+	const paths = [
+		{
+			path: join(gitDir, "index"),
+			basis: "a git index write"
+		},
+		{
+			path: join(gitDir, "HEAD"),
+			basis: "a git HEAD change"
+		},
+		{
+			path: join(gitDir, "logs", "HEAD"),
+			basis: "a git reflog entry"
+		}
+	];
+	for (const key of keys) {
+		const logs = logFiles$1(key);
+		if (logs === null) return null;
+		paths.push({
+			path: workspaceStateFile(key),
+			basis: "a Stim workspace state write"
+		}, ...logs);
+	}
+	const newest = newestMtime(paths);
+	return newest === "unreadable" ? null : newest;
+}
+function graceMsSetting() {
+	const { value, error } = machineNumber(GRACE_SETTING, loadConfig$1(), process.env);
+	if (error) {
+		const fallback = Number(settingDefinition(GRACE_SETTING)?.default);
+		console.error(chalk.yellow(`${error} gc uses the default of ${fallback} minutes.`));
+		return fallback * MINUTE_MS;
+	}
+	return (value ?? 0) * MINUTE_MS;
 }
 function porcelainOf(path, gitAnswered) {
 	if (gitAnswered === null) return null;
@@ -456,15 +666,15 @@ function porcelainOf(path, gitAnswered) {
 	return lines.length ? lines : null;
 }
 function candidateRoots() {
-	const registered = Object.keys(loadConfig()?.projects ?? {}).filter(isAbsolute);
+	const registered = Object.keys(loadConfig$1()?.projects ?? {}).filter(isAbsolute);
 	const recorded = listWorkspaceDirs().flatMap((entry) => entry.projectRoot ? [entry.projectRoot] : []);
-	return [.../* @__PURE__ */ new Set([...registered, ...recorded])].filter((root) => existsSync(root)).toSorted();
+	return [.../* @__PURE__ */ new Set([...registered, ...recorded])].filter((root) => existsSync$1(root)).toSorted();
 }
-function checkMergeStates(pending, idle, now) {
+function checkMergeStates(pending, idle, grace) {
 	const repos = /* @__PURE__ */ new Map();
 	for (const entry of pending) repos.set(entry.repo, [...repos.get(entry.repo) ?? [], entry]);
 	for (const [repo, entries] of repos) {
-		const target = fetchDefaultBranch(repo, now);
+		const target = fetchDefaultBranch(repo, grace.now);
 		for (const { candidate, facts } of entries) {
 			const merge = "error" in target ? {
 				merged: false,
@@ -474,21 +684,28 @@ function checkMergeStates(pending, idle, now) {
 			const verdict = worktreeSkipReason({
 				...facts,
 				merge
-			}, idle);
+			}, idle, grace);
 			Object.assign(candidate, {
 				merge,
 				skipCode: verdict?.code ?? null,
-				skipped: verdict?.text ?? null
+				skipped: verdict?.text ?? null,
+				eligibleAt: verdict?.eligibleAt ?? null
 			});
 		}
 	}
 }
 /**
 * Classifies each Stim-managed linked worktree. A merged one is removable; with `idle`, so is one unused for
-* `olderThan` days. Merge state is checked only where it decides the verdict, after one fetch per repository.
+* `olderThan` days. Device use is read last, in one pass against one simulator list and one AVD resolver, so
+* the resolver's time budget covers only device reads. Pull requests are asked once per repository, all
+* repositories at once. Merge state is checked only where it decides the verdict, after one fetch per repository.
 */
-function collectWorktreeSweep({ idle, olderThan, now }) {
+async function collectWorktreeSweep({ idle, olderThan, now }) {
 	const days = idle ? olderThan ?? DEFAULT_WORKTREE_IDLE_DAYS : null;
+	const grace = {
+		ms: graceMsSetting(),
+		now
+	};
 	const groups = /* @__PURE__ */ new Map();
 	const outside = [];
 	for (const root of candidateRoots()) {
@@ -499,15 +716,17 @@ function collectWorktreeSweep({ idle, olderThan, now }) {
 				keys: [root],
 				idleDays: null,
 				merge: null,
+				head: null,
+				pullRequest: null,
 				skipCode: "not-a-worktree",
-				skipped: "not inside a git worktree"
+				skipped: "not inside a git worktree",
+				eligibleAt: null
 			});
 			continue;
 		}
 		groups.set(entry.path, [...groups.get(entry.path) ?? [], root]);
 	}
-	const worktrees = [];
-	const pending = [];
+	const inspected = [];
 	for (const [path, roots] of groups) {
 		const entries = listWorktrees(path);
 		const entry = matchWorktreeEntry(entries, path);
@@ -515,7 +734,9 @@ function collectWorktreeSweep({ idle, olderThan, now }) {
 		const keys = [.../* @__PURE__ */ new Set([...roots, ...reclaimKeys(path)])];
 		const idleDays = idleDaysOf(keys, now);
 		const linked = !("refusal" in source) && entry !== null && source.path !== entry.path;
+		const activity = linked && grace.ms > 0 ? worktreeActivityOf(path, keys) : null;
 		const gitAnswered = linked ? hasUncommittedWork(path) : null;
+		const head = linked ? resolveFullRef(path, "HEAD") : null;
 		const facts = {
 			source: "refusal" in source ? source : linked ? "linked" : "source",
 			bare: Boolean(entry?.bare),
@@ -523,36 +744,82 @@ function collectWorktreeSweep({ idle, olderThan, now }) {
 			porcelain: porcelainOf(path, gitAnswered),
 			unpushed: linked ? unpushedCommits(path) : null,
 			submodules: linked && hasPopulatedSubmodules(path),
-			inUse: linked ? inUseOf(keys, { managedLocks: true }) : [],
-			idleDays,
-			merge: null
-		};
-		const verdict = worktreeSkipReason(facts, days);
-		const candidate = {
-			path,
-			keys,
+			inUse: [],
 			idleDays,
 			merge: null,
-			skipCode: verdict?.code ?? null,
-			skipped: verdict?.text ?? null
+			pullRequest: null,
+			activity
 		};
-		if (verdict && MERGE_DECIDES.has(verdict.code) && !("refusal" in source)) pending.push({
+		inspected.push({
+			candidate: {
+				path,
+				keys,
+				idleDays,
+				merge: null,
+				head,
+				pullRequest: null,
+				skipCode: null,
+				skipped: null,
+				eligibleAt: null
+			},
+			facts,
+			repo: "refusal" in source ? null : source.path,
+			branch: head && entry?.branch ? entry.branch : null
+		});
+	}
+	const linked = inspected.filter(({ facts }) => facts.source === "linked");
+	for (const { candidate, facts } of linked) facts.inUse = candidate.keys.flatMap((key) => workspaceInUse(key, { managedLocks: true }));
+	const devices = deviceReads();
+	for (const { candidate, facts } of linked) facts.inUse = [.../* @__PURE__ */ new Set([...facts.inUse, ...deviceUseOf(candidate.keys, devices)])];
+	await lookUpPullRequests(inspected);
+	const worktrees = [];
+	const pending = [];
+	for (const { candidate, facts, repo } of inspected) {
+		const verdict = worktreeSkipReason(facts, days, grace);
+		Object.assign(candidate, {
+			pullRequest: facts.pullRequest,
+			skipCode: verdict?.code ?? null,
+			skipped: verdict?.text ?? null,
+			eligibleAt: verdict?.eligibleAt ?? null
+		});
+		if (verdict && MERGE_DECIDES.has(verdict.code) && repo !== null) pending.push({
 			candidate,
 			facts,
-			repo: source.path
+			repo
 		});
 		worktrees.push(candidate);
 	}
-	checkMergeStates(pending, days, now);
+	checkMergeStates(pending, days, grace);
 	const listed = [...worktrees, ...outside].filter((w) => idle || w.skipCode !== "not-a-worktree" && w.skipCode !== "source-checkout");
 	return {
 		idle: days === null ? null : {
 			olderThan: days,
 			defaulted: olderThan === null
 		},
+		graceMs: grace.ms,
 		worktrees: listed
 	};
 }
+async function lookUpPullRequests(inspected) {
+	const repos = /* @__PURE__ */ new Map();
+	for (const { candidate, facts, repo, branch } of inspected) {
+		if (repo === null || branch === null || candidate.head === null) continue;
+		const query = {
+			cwd: candidate.path,
+			branch,
+			head: candidate.head
+		};
+		repos.set(repo, [...repos.get(repo) ?? [], {
+			facts,
+			query
+		}]);
+	}
+	const lookup = pullRequestLookups();
+	await Promise.all([...repos].map(async ([repo, entries]) => {
+		const answers = await lookup(repo, entries.map(({ query }) => query));
+		entries.forEach(({ facts }, i) => facts.pullRequest = answers[i] ?? null);
+	}));
+}
 async function removeWorktrees(sweep, { now = Date.now() } = {}) {
 	let failures = 0;
 	for (const candidate of sweep.worktrees) {
@@ -562,31 +829,51 @@ async function removeWorktrees(sweep, { now = Date.now() } = {}) {
 			const keys = [.../* @__PURE__ */ new Set([...candidate.keys, ...lockedKeys])];
 			const unlocked = keys.filter((key) => !lockedKeys.includes(key));
 			const reasons = [...inUseOf(lockedKeys, { managedLocks: false }), ...inUseOf(unlocked, { managedLocks: true })].map((r) => `in use: ${r}`);
-			if (candidate.merge?.merged) {
-				if (resolveFullRef(candidate.path, "HEAD") !== candidate.merge.head) reasons.push("its HEAD moved since gc checked it");
+			const mergedHead = candidate.merge?.merged ? candidate.merge.head : endedPullRequest(candidate.pullRequest) ? candidate.head : null;
+			if (mergedHead) {
+				if (resolveFullRef(candidate.path, "HEAD") !== mergedHead) reasons.push("its HEAD moved since gc checked it");
 			} else {
 				const idleDays = idleDaysOf(keys, now);
 				if (idleDays === null || !sweep.idle || idleDays < sweep.idle.olderThan) reasons.push(`used ${idleDays === null ? "at an unknown time" : `${idleDays}d ago`} since gc checked it`);
 			}
+			if (sweep.graceMs > 0) {
+				const recent = graceBlocker({
+					merge: candidate.merge,
+					pullRequest: candidate.pullRequest,
+					activity: worktreeActivityOf(candidate.path, keys)
+				}, {
+					ms: sweep.graceMs,
+					now: Date.now()
+				});
+				if (recent) reasons.push(recent.text);
+			}
 			kept = reasons;
 			return reasons;
 		};
 		let removed = false;
+		let error = null;
 		try {
-			const mergedHead = candidate.merge?.merged && candidate.merge.coversUnpushed ? candidate.merge.head : void 0;
+			const ended = endedPullRequest(candidate.pullRequest);
+			const mergedHead = candidate.merge?.merged && candidate.merge.coversUnpushed ? candidate.merge.head : ended?.state === "merged" ? candidate.head ?? void 0 : void 0;
 			removed = await removeWorktreeTarget(candidate.path, {
 				linkedOnly: true,
 				guard,
 				mergedHead
 			});
-		} catch (error) {
-			console.error(chalk.red(`Could not remove ${candidate.path}: ${error?.message || String(error)}`));
+		} catch (thrown) {
+			error = thrown?.message || String(thrown);
+			console.error(chalk.red(`Could not remove ${candidate.path}: ${error}`));
 		}
-		if (removed) console.log(chalk.green(`Removed the worktree ${candidate.path} (${worktreeRemovalReason(candidate)})`));
-		else if (kept.length) console.log(chalk.yellow(`Kept the worktree ${candidate.path}: ${kept.join("; ")}`));
-		else {
+		if (removed) {
+			console.log(chalk.green(`Removed the worktree ${candidate.path} (${worktreeRemovalReason(candidate)})`));
+			recordGcResult("worktree", "done", candidate.path, { detail: worktreeRemovalReason(candidate) });
+		} else if (kept.length) {
+			console.log(chalk.yellow(`Kept the worktree ${candidate.path}: ${kept.join("; ")}`));
+			recordGcResult("worktree", "kept", candidate.path, { detail: kept.join("; ") });
+		} else {
 			failures++;
 			console.error(chalk.yellow(`Kept the worktree ${candidate.path}; see the lines above for why.`));
+			recordGcResult("worktree", "failed", candidate.path, { detail: error ?? "stim worktree remove did not remove it; see the details" });
 		}
 	}
 	return failures;
@@ -641,7 +928,7 @@ function unresolvedLockLines(locks, slots) {
 		"              run that yourself once you know nothing is building with it"
 	];
 }
-function formatGcReport({ skipped = [], deadProjects = [], orphanedPorts, invalidProjects = [], orphanedWorkspaces = [], parkedSims = [], parkedAvds = [], orphanedDevices = [], unverifiedDevices = [], staleDevices = [], staleDeviceRecords = [], buildLocks = {
+function formatGcReport({ skipped = [], deadProjects = [], orphanedPorts, invalidProjects = [], orphanedWorkspaces = [], parkedSims = [], parkedAvds = [], orphanedDevices = [], unverifiedDevices = [], staleDevices = [], staleDeviceRecords = [], staleLedgerEntries = [], buildLocks = {
 	stale: [],
 	live: [],
 	unresolved: []
@@ -657,7 +944,7 @@ function formatGcReport({ skipped = [], deadProjects = [], orphanedPorts, invali
 	orphaned: [],
 	notices: [],
 	deletionSafe: true
-}, caches = [], workspaceOutputs = null, worktreeSweep = null, cacheScope = null, olderThan = null }, { now = Date.now() } = {}) {
+}, caches = [], workspaceOutputs = null, workspaceLogs = [], worktreeSweep = null, cacheScope = null, olderThan = null }, { now = Date.now() } = {}) {
 	const lines = [];
 	const staleLocks = buildLocks?.stale ?? [];
 	const liveLocks = buildLocks?.live ?? [];
@@ -673,11 +960,13 @@ function formatGcReport({ skipped = [], deadProjects = [], orphanedPorts, invali
 		orphanedDevices,
 		staleDevices,
 		staleDeviceRecords,
+		staleLedgerEntries,
 		staleLocks,
 		staleSlots,
 		expiredLeases,
 		easSessionSweep.orphaned,
 		workspaceOutputs?.workspaces.filter((entry) => entry.willClear) ?? [],
+		workspaceLogs.filter((entry) => entry.willTrim),
 		worktreeSweep?.worktrees.filter((entry) => !entry.skipped) ?? []
 	].every((found) => found.length === 0)) {
 		const reasons = [];
@@ -699,7 +988,7 @@ function formatGcReport({ skipped = [], deadProjects = [], orphanedPorts, invali
 		for (const d of orphanedDevices) lines.push(`  ${d.kind} ${d.name} (${d.id})${deviceSizeSuffix(d)}`);
 	}
 	if (unverifiedDevices.length) {
-		lines.push(`Unrecognized stim-* devices (${unverifiedDevices.length}) - NOT deleted, because Stim has no record of creating them:`);
+		lines.push(`Unrecognized stim-* devices (${unverifiedDevices.length}) - NOT deleted, because this Stim home has no record of creating them:`);
 		for (const d of unverifiedDevices) {
 			lines.push(`  ${d.kind} ${d.name} (${d.id})`);
 			lines.push(`              ${unverifiedDeviceCommand(d)}`);
@@ -722,6 +1011,11 @@ function formatGcReport({ skipped = [], deadProjects = [], orphanedPorts, invali
 		}
 		lines.push("              --delete clears the RECORD only; there is no device left to touch.");
 	}
+	if (staleLedgerEntries.length) {
+		lines.push(`Stale device ledger entries (${staleLedgerEntries.length}) - Stim created these devices or browser profiles; they are gone:`);
+		for (const entry of staleLedgerEntries) lines.push(`  ${entry.kind} ${entry.id} is not on this machine`);
+		lines.push("              --delete forgets the LEDGER ENTRY only; there is no device left to touch.");
+	}
 	if (easSessionSweep.orphaned.length) {
 		lines.push(`Orphaned EAS sessions (${easSessionSweep.orphaned.length}) - current EAS project only:`);
 		for (const session of easSessionSweep.orphaned) {
@@ -766,9 +1060,21 @@ function formatGcReport({ skipped = [], deadProjects = [], orphanedPorts, invali
 		lines.push(`Skipped (${skipped.length}) - not classified as dead:`);
 		for (const entry of skipped) lines.push(`  ${entry.dir}: ${entry.reason}`);
 	}
+	lines.push(...workspaceLogLines(workspaceLogs));
 	lines.push(...cacheLines(caches, workspaceOutputs));
 	return lines;
 }
+function workspaceLogLines(workspaceLogs) {
+	const over = workspaceLogs.filter((w) => w.trimBytes > 0);
+	if (!over.length) return [];
+	const total = workspaceLogs.reduce((n, w) => n + w.bytes, 0);
+	const lines = [`Workspace logs (${formatBytes(total)} in ${workspaceLogs.length} workspace${workspaceLogs.length === 1 ? "" : "s"}) - ${over.length} with a log over twice the 8 MiB cap:`];
+	for (const w of over) {
+		lines.push(`  ${formatBytes(w.bytes).padStart(10)}  ${w.projectRoot ?? w.dir}`);
+		lines.push(w.willTrim ? `              would TRIM ${formatBytes(w.trimBytes)}: Metro, client and device logs keep their newest 8 MiB` : `              kept: ${w.keptReason}`);
+	}
+	return lines;
+}
 function leaseGarbageLines({ expired, kept }) {
 	const lines = [];
 	if (expired.length) {
@@ -787,7 +1093,7 @@ function leaseGarbageLines({ expired, kept }) {
 	return lines;
 }
 function deviceSizeSuffix(device) {
-	return device.kind === "android" && device.bytes !== void 0 ? ` - ${formatBytes(device.bytes)} on disk` : "";
+	return device.bytes !== void 0 ? ` - ${formatBytes(device.bytes)} on disk` : "";
 }
 function namedPortLines(ports = []) {
 	if (!ports.length) return [];
@@ -855,11 +1161,14 @@ function worktreeSweepLines(sweep) {
 	if (!sweep || !sweep.idle && !sweep.worktrees.length) return [];
 	const removable = sweep.worktrees.filter((w) => !w.skipped);
 	const idle = !sweep.idle ? "" : sweep.idle.defaulted ? `, or clean, pushed and idle ${sweep.idle.olderThan}d or more (the default without --older-than)` : `, or clean, pushed and idle ${sweep.idle.olderThan}d or more`;
-	const lines = [`Linked worktrees (${removable.length} removable, ${sweep.worktrees.length - removable.length} kept) - clean and merged into the default branch${idle}:`];
+	const lines = [`Linked worktrees (${removable.length} removable, ${sweep.worktrees.length - removable.length} kept) - clean and merged into the default branch, or with a merged or closed pull request${idle}:`];
+	const unknown = new Set(sweep.worktrees.flatMap((w) => w.pullRequest && "unavailable" in w.pullRequest ? [w.pullRequest.unavailable] : []));
+	for (const reason of unknown) lines.push(`  Pull request state unknown (${reason}); merges are judged from git alone.`);
 	for (const w of sweep.worktrees) {
 		const age = w.idleDays === null ? "" : ` (idle ${w.idleDays}d)`;
 		lines.push(`  ${w.path}${age}`);
-		lines.push(w.skipped ? `              kept: ${w.skipped}` : `              would be REMOVED by \`stim worktree remove\`: ${worktreeRemovalReason(w)}`);
+		const note = worktreePullRequestNote(w);
+		lines.push(w.skipped ? `              kept: ${w.skipped}${note && !w.skipped.includes(note) ? ` (${note})` : ""}` : `              would be REMOVED by \`stim worktree remove\`: ${worktreeRemovalReason(w)}`);
 	}
 	if (removable.length) lines.push("              --delete runs it without --force; use, idleness and HEAD are re-checked under its removal locks.");
 	return lines;
@@ -873,7 +1182,16 @@ function jsonLock({ path, platform, key, pid, projectRoot }) {
 		projectRoot
 	};
 }
-function gcReportSections({ skipped = [], deadProjects = [], orphanedPorts = [], invalidProjects = [], orphanedWorkspaces = [], worktreeSweep = null, parkedSims = [], parkedAvds = [], orphanedDevices = [], unverifiedDevices = [], staleDevices = [], staleDeviceRecords = [], buildLocks = {
+function jsonPullRequest(lookup) {
+	const pr = lookup && "pullRequest" in lookup ? lookup.pullRequest : null;
+	return pr ? {
+		number: pr.number,
+		state: pr.state,
+		url: pr.url,
+		containsHead: pr.containsHead
+	} : null;
+}
+function gcReportSections({ skipped = [], deadProjects = [], orphanedPorts = [], invalidProjects = [], orphanedWorkspaces = [], worktreeSweep = null, parkedSims = [], parkedAvds = [], orphanedDevices = [], unverifiedDevices = [], staleDevices = [], staleDeviceRecords = [], staleLedgerEntries = [], buildLocks = {
 	stale: [],
 	live: [],
 	unresolved: []
@@ -889,7 +1207,7 @@ function gcReportSections({ skipped = [], deadProjects = [], orphanedPorts = [],
 	orphaned: [],
 	notices: [],
 	deletionSafe: true
-}, workspaceOutputs = null, caches = [] }) {
+}, workspaceOutputs = null, workspaceLogs = [], caches = [] }) {
 	return {
 		deadProjects: deadProjects.map((path) => ({ path })),
 		invalidProjects: invalidProjects.map((path) => ({ path })),
@@ -907,9 +1225,12 @@ function gcReportSections({ skipped = [], deadProjects = [], orphanedPorts = [],
 			path: w.path,
 			idleDays: w.idleDays,
 			mergedInto: w.merge?.merged ? w.merge.into : null,
+			pullRequest: jsonPullRequest(w.pullRequest),
+			pullRequestUnknown: w.pullRequest && "unavailable" in w.pullRequest ? w.pullRequest.unavailable : null,
 			willRemove: w.skipCode === null,
 			reason: w.skipCode,
-			detail: w.skipped ?? worktreeRemovalReason(w)
+			detail: w.skipped ?? worktreeRemovalReason(w),
+			eligibleAt: w.eligibleAt === null ? null : new Date(w.eligibleAt).toISOString()
 		})),
 		parkedSimulators: parkedSims.map(({ udid, name, model, runtime, parkedAt, bytes, listed }) => ({
 			udid,
@@ -956,6 +1277,10 @@ function gcReportSections({ skipped = [], deadProjects = [], orphanedPorts = [],
 			project: r.project,
 			slot: r.slot ?? null
 		})),
+		staleLedgerEntries: staleLedgerEntries.map(({ kind, id }) => ({
+			kind,
+			id
+		})),
 		idleDevices: idleDevices.map(({ kind, id, name, project, slot, lastActivityAt, idleForMs, buildInProgress }) => ({
 			kind,
 			id,
@@ -1007,6 +1332,15 @@ function gcReportSections({ skipped = [], deadProjects = [], orphanedPorts = [],
 			path: dir,
 			detail: reason
 		})),
+		workspaceLogs: workspaceLogs.map((w) => ({
+			dir: w.dir,
+			projectRoot: w.projectRoot,
+			bytes: w.bytes,
+			trimBytes: w.trimBytes,
+			willTrim: w.willTrim,
+			reason: w.keptCode,
+			detail: w.keptReason
+		})),
 		workspaceBuildOutputs: (workspaceOutputs?.workspaces ?? []).map((w) => ({
 			dir: w.dir,
 			projectRoot: w.projectRoot,
@@ -1028,11 +1362,505 @@ function gcReportSections({ skipped = [], deadProjects = [], orphanedPorts = [],
 	};
 }
 //#endregion
+//#region src/commands/gc/ledger.ts
+/** `sims` must be a complete listing, unavailable simulators included, taken after `ledger` was read. */
+function findStaleLedgerEntries(ledger, sims) {
+	const listed = new Set(sims.map((sim) => sim.udid));
+	return [...ledger.ios].filter((udid) => !listed.has(udid)).map((id) => ({
+		kind: "ios",
+		id
+	}));
+}
+/**
+* `registered` must come from an emulator listing that succeeded after `ledger` was read. A name stays while an
+* unfinished setup reserves it, or while any AVD root could still hold it.
+*/
+function findStaleAndroidLedgerEntries(ledger, registered, config) {
+	const listed = new Set(registered);
+	return [...ledger.android].filter((name) => !listed.has(name) && isStaleAvdName(name, config)).map((id) => ({
+		kind: "android",
+		id
+	}));
+}
+function isStaleAvdName(name, config) {
+	try {
+		return !reservedForSetup(name, config) && avdNameAbsent(name);
+	} catch {
+		return false;
+	}
+}
+function reservedForSetup(name, config) {
+	return Object.values(config?.projects ?? {}).some((project) => projectDeviceSlots(project).some(({ platforms }) => platforms.android?.setupIncomplete && platforms.android.avdName === name));
+}
+function forgetStaleAvdName(name) {
+	let claim = null;
+	try {
+		claim = acquireAvdClaim(name);
+		return withConfigLock$1(() => {
+			if (!isStaleAvdName(name, loadConfig$1())) return false;
+			forgetCreatedDevice("android", name);
+			return true;
+		});
+	} finally {
+		(0, ownership_claim_exports.releaseClaim)(claim);
+	}
+}
+/**
+* Browser profiles the ledger lists whose directory is gone while the workspaces directory that held it is
+* present and the workspace is not a link to a missing volume, so an unmounted volume never reads as a deleted
+* profile.
+*/
+function staleBrowserProfiles(ledger, exists = existsSync) {
+	return [...ledger.web].filter((path) => isStaleProfile(path, exists)).map((id) => ({
+		kind: "web",
+		id
+	}));
+}
+function isStaleProfile(path, exists) {
+	const workspace = dirname$1(dirname$1(path));
+	return !exists(path) && exists(dirname$1(workspace)) && !isDanglingLink(workspace);
+}
+function isDanglingLink(path) {
+	try {
+		return lstatSync(path).isSymbolicLink() && !existsSync(path);
+	} catch {
+		return false;
+	}
+}
+function forgetStaleLedgerEntries(entries) {
+	let failures = 0;
+	for (const entry of entries) {
+		if (entry.kind === "web" && !isStaleProfile(entry.id, existsSync)) continue;
+		try {
+			if (entry.kind === "android") {
+				if (!forgetStaleAvdName(entry.id)) {
+					console.log(chalk.dim(`Kept the ledger entry for android ${entry.id}: the AVD or its setup reappeared`));
+					continue;
+				}
+			} else forgetCreatedDevice(entry.kind, entry.id);
+			console.log(chalk.green(`Forgot the ledger entry for ${entry.kind} ${entry.id} (not on this machine)`));
+		} catch (error) {
+			failures++;
+			console.log(chalk.red(`Could not forget the ledger entry for ${entry.kind} ${entry.id}: ${error?.message || error}`));
+		}
+	}
+	return failures;
+}
+//#endregion
+//#region src/commands/gc/logs.ts
+const CAPPED_LOGS = [
+	"metro.ndjson",
+	"client.ndjson",
+	"device.ndjson"
+];
+const TRIM_ABOVE_BYTES = 2 * LOG_ROTATE_BYTES;
+function fileSize(path) {
+	try {
+		const stat = statSync$1(path);
+		return stat.isFile() ? stat.size : 0;
+	} catch {
+		return 0;
+	}
+}
+function cappedFiles(logsDir) {
+	return CAPPED_LOGS.flatMap((name) => {
+		const log = join(logsDir, name);
+		return [{
+			file: log,
+			log
+		}, {
+			file: rotatedLogPath(log),
+			log
+		}];
+	});
+}
+function trimmable(size) {
+	return size > TRIM_ABOVE_BYTES ? size - LOG_ROTATE_BYTES : 0;
+}
+function excess(logsDir) {
+	return cappedFiles(logsDir).reduce((sum, { file }) => sum + trimmable(fileSize(file)), 0);
+}
+function collectorReason(root) {
+	const platforms = Object.keys(readCollectors(root));
+	return platforms.length ? `a device log collector is recorded for ${platforms.join(", ")}` : null;
+}
+function collectWorkspaceLogs({ exclude = [] } = {}) {
+	const mountedVolumes = listMountedVolumes();
+	const entries = [];
+	for (const { dir, projectRoot, problem } of listWorkspaceDirs()) {
+		if (exclude.includes(dir)) continue;
+		if (projectRoot !== null && !isOnMountedVolume(projectRoot, mountedVolumes)) continue;
+		const logsDir = join(dir, "logs");
+		let names;
+		try {
+			names = readdirSync$1(logsDir);
+		} catch {
+			continue;
+		}
+		const bytes = names.reduce((sum, name) => sum + fileSize(join(logsDir, name)), 0);
+		if (bytes === 0) continue;
+		const trimBytes = excess(logsDir);
+		let keptCode = null;
+		let keptReason = null;
+		if (trimBytes > 0) {
+			if (projectRoot === null) {
+				keptCode = "unresolved";
+				keptReason = `workspace directory not resolved: ${problem ?? "unknown project root"}`;
+			} else {
+				const inUse = workspaceInUse(projectRoot);
+				const collector = collectorReason(projectRoot);
+				if (inUse.length) {
+					keptCode = "in-use";
+					keptReason = `in use: ${inUse.join("; ")}`;
+				} else if (collector) {
+					keptCode = "collector";
+					keptReason = collector;
+				}
+			}
+		}
+		entries.push({
+			dir,
+			projectRoot,
+			bytes,
+			trimBytes,
+			willTrim: trimBytes > 0 && keptCode === null,
+			keptCode,
+			keptReason
+		});
+	}
+	return entries;
+}
+function trimToNewest({ file, log }, maxBytes) {
+	if (!trimmable(fileSize(file))) return 0;
+	return withDirLock(`${log}.lock`, () => {
+		const { size, atime, mtime } = statSync$1(file);
+		if (!trimmable(size)) return 0;
+		const tail = Buffer.alloc(maxBytes);
+		const fd = openSync$1(file, "r");
+		try {
+			readSync$1(fd, tail, 0, maxBytes, size - maxBytes);
+		} finally {
+			closeSync$1(fd);
+		}
+		const newline = tail.indexOf(10);
+		const kept = newline === -1 ? Buffer.alloc(0) : tail.subarray(newline + 1);
+		const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+		try {
+			writeFileSync$1(tmp, kept);
+			utimesSync(tmp, atime, mtime);
+			renameSync$1(tmp, file);
+		} catch (error) {
+			rmSync$1(tmp, { force: true });
+			throw error;
+		}
+		return size - kept.length;
+	});
+}
+async function trimWorkspaceLogs(entries) {
+	let failures = 0;
+	let trimmed = 0;
+	for (const entry of entries) {
+		const root = entry.projectRoot;
+		if (!entry.willTrim || root === null) {
+			if (entry.keptReason) console.log(chalk.dim(`Kept the logs of ${root ?? entry.dir}: ${entry.keptReason}`));
+			continue;
+		}
+		let run;
+		try {
+			run = await withIdleWorkspace(root, () => {
+				const collector = collectorReason(root);
+				if (collector) return {
+					kept: collector,
+					bytes: 0
+				};
+				return {
+					kept: null,
+					bytes: cappedFiles(join(entry.dir, "logs")).reduce((sum, capped) => sum + trimToNewest(capped, LOG_ROTATE_BYTES), 0)
+				};
+			}, { purpose: "gc" });
+		} catch (error) {
+			failures++;
+			console.log(chalk.red(`Could not trim the logs of ${root}: ${error?.message || String(error)}`));
+			continue;
+		}
+		if (!run.ran || run.value.kept) {
+			const kept = run.ran ? run.value.kept : `in use: ${run.reasons.join("; ")}`;
+			console.log(chalk.yellow(`Kept the logs of ${root}: ${kept}`));
+			continue;
+		}
+		trimmed += run.value.bytes;
+		console.log(chalk.green(`Trimmed the logs of ${root} (${formatBytes(run.value.bytes)})`));
+	}
+	if (trimmed) console.log(chalk.dim(`Trimmed ${formatBytes(trimmed)} of workspace logs.`));
+	return failures;
+}
+//#endregion
+//#region src/commands/gc/inventory.ts
+const IOS_SIMULATOR_PLATFORM = "com.apple.platform.iphonesimulator";
+function text(value) {
+	return typeof value === "string" && value.length > 0 ? value : null;
+}
+function parseSimRuntimeList(jsonOutput) {
+	const parsed = JSON.parse(jsonOutput);
+	if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("Expected simctl runtime list to return a JSON object.");
+	const runtimes = [];
+	for (const [key, value] of Object.entries(parsed)) {
+		if (value === null || typeof value !== "object" || Array.isArray(value)) continue;
+		const entry = value;
+		if (entry.platformIdentifier !== IOS_SIMULATOR_PLATFORM) continue;
+		runtimes.push({
+			identifier: text(entry.identifier) ?? key,
+			runtimeIdentifier: text(entry.runtimeIdentifier),
+			version: text(entry.version),
+			build: text(entry.build),
+			sizeBytes: typeof entry.sizeBytes === "number" && Number.isFinite(entry.sizeBytes) ? entry.sizeBytes : null,
+			deletable: entry.deletable === true,
+			lastUsedAt: text(entry.lastUsedAt)
+		});
+	}
+	return runtimes;
+}
+function unlistedRuntimes(jsonOutput, images) {
+	const known = new Set(images.map((image) => image.runtimeIdentifier));
+	const parsed = JSON.parse(jsonOutput);
+	if (!Array.isArray(parsed.runtimes)) throw new Error("Expected simctl list runtimes to return a runtimes array.");
+	return parsed.runtimes.flatMap((value) => {
+		if (value === null || typeof value !== "object") return [];
+		const entry = value;
+		const identifier = text(entry.identifier);
+		if (!identifier || !/\.iOS-/.test(identifier) || known.has(identifier)) return [];
+		return [{
+			identifier,
+			runtimeIdentifier: identifier,
+			version: text(entry.version),
+			build: text(entry.buildversion),
+			sizeBytes: null,
+			deletable: false,
+			lastUsedAt: null
+		}];
+	});
+}
+function modelName(deviceTypeIdentifier) {
+	return deviceTypeIdentifier.replace(/^com\.apple\.CoreSimulator\.SimDeviceType\./, "").replaceAll("-", " ");
+}
+function sdkmanagerCommand(pkg) {
+	const tool = androidToolPath("sdkmanager");
+	return `${tool === "sdkmanager" ? tool : JSON.stringify(tool)} --uninstall ${JSON.stringify(pkg)}`;
+}
+function buildInventory({ sims, avds, runtimes, systemImages, config, deadProjects = [] }) {
+	const dead = new Set(deadProjects);
+	const assigned = /* @__PURE__ */ new Map();
+	for (const [project, record] of Object.entries(config?.projects ?? {})) {
+		if (dead.has(project)) continue;
+		let slots;
+		try {
+			slots = projectDeviceSlots(record);
+		} catch {
+			continue;
+		}
+		for (const { slot, platforms } of slots) {
+			if (platforms.ios?.deviceUdid) assigned.set(`ios:${platforms.ios.deviceUdid}`, {
+				project,
+				slot
+			});
+			if (platforms.android?.avdName) assigned.set(`android:${platforms.android.avdName}`, {
+				project,
+				slot
+			});
+		}
+	}
+	const parked = /* @__PURE__ */ new Set([...readParked("ios", { config }).map((sim) => `ios:${sim.udid}`), ...readParked("android", { config }).map((avd) => `android:${avd.name}`)]);
+	const owner = (key, name, created) => {
+		const workspace = assigned.get(key);
+		if (workspace && created()) return {
+			owner: "workspace",
+			project: workspace.project,
+			slot: workspace.slot
+		};
+		if (parked.has(key)) return {
+			owner: "parked",
+			project: null,
+			slot: null
+		};
+		if (!name.startsWith("stim-")) return {
+			owner: "user",
+			project: null,
+			slot: null
+		};
+		return {
+			owner: created() ? "orphaned" : "otherStimHome",
+			project: null,
+			slot: null
+		};
+	};
+	const devices = [...sims.map((sim) => ({
+		kind: "ios",
+		id: sim.udid,
+		name: sim.name,
+		model: modelName(sim.deviceTypeIdentifier),
+		runtime: sim.runtime,
+		state: sim.state,
+		lastUsedAt: sim.lastUsedAt ?? null,
+		bytes: sim.dataPathSize ?? null,
+		directory: sim.dataPath ? sim.dataPath.replace(/\/data\/?$/, "") : null,
+		...owner(`ios:${sim.udid}`, sim.name, () => isStimOwnedSim({
+			udid: sim.udid,
+			name: sim.name
+		}))
+	})), ...avds.map((avd) => ({
+		kind: "android",
+		id: avd.name,
+		name: avd.name,
+		model: avd.deviceProfile,
+		runtime: avd.systemImage,
+		state: null,
+		lastUsedAt: avd.lastUsedAt,
+		bytes: null,
+		directory: avd.directory,
+		...owner(`android:${avd.name}`, avd.name, () => isStimOwnedAvd(avd.name))
+	}))];
+	const simsByRuntime = /* @__PURE__ */ new Map();
+	for (const sim of sims) simsByRuntime.set(sim.runtime, (simsByRuntime.get(sim.runtime) ?? 0) + 1);
+	const avdsByImage = /* @__PURE__ */ new Map();
+	for (const avd of avds) if (avd.systemImage) avdsByImage.set(avd.systemImage, (avdsByImage.get(avd.systemImage) ?? 0) + 1);
+	return {
+		devices,
+		runtimes: runtimes.map((runtime) => ({
+			identifier: runtime.identifier,
+			runtimeIdentifier: runtime.runtimeIdentifier,
+			version: runtime.version,
+			build: runtime.build,
+			bytes: runtime.sizeBytes,
+			lastUsedAt: runtime.lastUsedAt,
+			deviceCount: runtime.runtimeIdentifier ? simsByRuntime.get(runtime.runtimeIdentifier) ?? 0 : 0,
+			command: runtime.deletable ? `xcrun simctl runtime delete ${runtime.identifier}` : null
+		})),
+		systemImages: systemImages.map((image) => ({
+			package: image.pkg,
+			directory: image.directory,
+			avdCount: avdsByImage.get(image.pkg) ?? 0,
+			command: sdkmanagerCommand(image.pkg)
+		}))
+	};
+}
+function modifiedAt(path) {
+	try {
+		return statSync(path).mtime.toISOString();
+	} catch {
+		return null;
+	}
+}
+function isMissing(error) {
+	const code = error.code;
+	return code === "ENOENT" || code === "ENOTDIR";
+}
+function unreadableNotice(what, error) {
+	const notice = `${what} not listed: ${describeError(error)}`;
+	if (process.platform !== "darwin" || error.code !== "EPERM") return notice;
+	return `${notice}. macOS privacy protection blocked the read; allow ${process.env.STIM_DESKTOP_APP ? "Stim Desktop" : "the app that runs stim"} under System Settings > Privacy & Security > Files and Folders (Removable Volumes for an external disk) or Full Disk Access`;
+}
+function listAvdRecords(notices, roots = avdStorageRoots()) {
+	const records = /* @__PURE__ */ new Map();
+	for (const root of roots) {
+		let names;
+		try {
+			names = readdirSync(root);
+		} catch (error) {
+			if (!isMissing(error)) notices.push(unreadableNotice(`AVDs in ${root}`, error));
+			continue;
+		}
+		for (const entry of names) {
+			if (!entry.endsWith(".ini")) continue;
+			const name = entry.slice(0, -4);
+			if (records.has(name)) continue;
+			let ini;
+			try {
+				ini = readFileSync(join$1(root, entry), "utf8");
+			} catch (error) {
+				if (!isMissing(error)) notices.push(unreadableNotice(`AVD ${name}`, error));
+				continue;
+			}
+			let directory = null;
+			let config = "";
+			let unreadable = null;
+			for (const candidate of avdIniPaths(root, ini)) try {
+				config = readFileSync(join$1(candidate, "config.ini"), "utf8");
+				directory = candidate;
+				break;
+			} catch (error) {
+				if (!isMissing(error)) unreadable ??= error;
+			}
+			if (!directory && unreadable) notices.push(unreadableNotice(`details of AVD ${name}`, unreadable));
+			records.set(name, {
+				name,
+				directory,
+				systemImage: parseAvdSystemImage(config),
+				deviceProfile: parseAvdDeviceProfile(config),
+				lastUsedAt: directory ? modifiedAt(join$1(directory, "hardware-qemu.ini")) : null
+			});
+		}
+	}
+	return [...records.values()];
+}
+function simctl(args) {
+	return getExecutor().runFile("xcrun", ["simctl", ...args], {
+		timeoutMs: DEVICE_LIST_TIMEOUT_MS,
+		killSignal: "SIGKILL"
+	});
+}
+function collectInventory(config, deadProjects) {
+	const notices = [];
+	let sims = [];
+	let runtimes = [];
+	if (process.platform === "darwin") {
+		try {
+			sims = listAllIosSims({ timeoutMs: DEVICE_LIST_TIMEOUT_MS });
+		} catch (error) {
+			notices.push(`simulators not listed: ${describeError(error)}`);
+		}
+		try {
+			runtimes = parseSimRuntimeList(simctl([
+				"runtime",
+				"list",
+				"-j"
+			]));
+		} catch (error) {
+			notices.push(`simulator runtime images not listed: ${describeError(error)}`);
+		}
+		try {
+			runtimes.push(...unlistedRuntimes(simctl([
+				"list",
+				"runtimes",
+				"-j"
+			]), runtimes));
+		} catch (error) {
+			notices.push(`simulator runtimes not listed: ${describeError(error)}`);
+		}
+	}
+	const imagesRoot = join$1(androidHome(), "system-images");
+	const images = listInstalledSystemImages((error) => notices.push(unreadableNotice("Android system images", error))).map((image) => ({
+		pkg: image.pkg,
+		directory: join$1(imagesRoot, `android-${image.api}`, image.tag, image.arch)
+	}));
+	return {
+		...buildInventory({
+			sims,
+			avds: listAvdRecords(notices),
+			runtimes,
+			systemImages: images,
+			config,
+			deadProjects
+		}),
+		notices
+	};
+}
+//#endregion
 //#region src/commands/gc.ts
 function removeInvalidProjectEntries(invalidProjects) {
 	for (const path of invalidProjects) {
 		removeProject(path);
 		console.log(chalk.green(`Removed the invalid registry entry ${path}`));
+		recordGcResult("project", "done", path);
 	}
 }
 async function collectGcReport({ olderThan = null, cache = null, worktrees = false, now = Date.now(), lastTouched = workspaceLastUsed } = {}, deps = {}) {
@@ -1050,6 +1878,7 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 		unverifiedDevices: [],
 		staleDevices: [],
 		staleDeviceRecords: [],
+		staleLedgerEntries: [],
 		buildLocks: {
 			stale: [],
 			live: [],
@@ -1079,13 +1908,14 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 			olderThan,
 			now
 		}) : null,
+		workspaceLogs: [],
 		worktreeSweep: null,
 		cacheScope: scope,
 		olderThan,
 		all
 	};
 	const mountedVolumes = listMountedVolumes();
-	const cfg = loadConfig();
+	const cfg = loadConfig$1();
 	let easSessionSweep = deps.precollectedEasSessionSweep;
 	if (!easSessionSweep) try {
 		easSessionSweep = collectEasSessionSweep(cfg, deps);
@@ -1118,7 +1948,7 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 			else invalidProjects.push(path);
 			continue;
 		}
-		if (existsSync(path)) continue;
+		if (existsSync$1(path)) continue;
 		if (!isOnMountedVolume(path, mountedVolumes)) {
 			const volume = volumeRootFor(path);
 			skipped.push({
@@ -1134,6 +1964,7 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 	let unverifiedDevices = [];
 	let staleDevices = [];
 	let staleDeviceRecords = [];
+	let staleLedgerEntries = staleBrowserProfiles(readCreatedDevices$1());
 	let idleDevices = [];
 	const unsweepableReason = cfg === null ? "no Stim config found" : deviceSweepIsScoped() ? "STIM_HOME scopes this config, but simulators and AVDs are machine-global" : null;
 	if (unsweepableReason) {
@@ -1149,8 +1980,14 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 	} else {
 		let sims = [];
 		let simsChecked = true;
+		const ledger = readCreatedDevices$1();
 		try {
-			sims = listAllIosSims({ timeoutMs: DEVICE_LIST_TIMEOUT_MS });
+			const allSims = listAllIosSims({
+				timeoutMs: DEVICE_LIST_TIMEOUT_MS,
+				includeUnavailable: true
+			});
+			staleLedgerEntries = [...staleLedgerEntries, ...findStaleLedgerEntries(ledger, allSims)];
+			sims = allSims.filter((sim) => sim.available);
 		} catch {
 			simsChecked = false;
 			deviceSweepNotices.push(`ios device sweep skipped: simulator tooling did not answer within ${DEVICE_LIST_TIMEOUT_MS / 1e3}s`);
@@ -1170,6 +2007,8 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 			avdsChecked = false;
 			deviceSweepNotices.push(`android data sweep skipped: ${error.message}`);
 		}
+		if (avdsChecked) staleLedgerEntries = [...staleLedgerEntries, ...findStaleAndroidLedgerEntries(ledger, avds, loadConfig$1())];
+		const registeredAvds = new Set(avds);
 		avds = [.../* @__PURE__ */ new Set([...avds, ...orphanedAvdDirectories.map((entry) => entry.name)])];
 		const isMounted = (path) => isOnMountedVolume(path, mountedVolumes);
 		const found = findOrphanedDevices({
@@ -1177,13 +2016,12 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 			avds,
 			config: cfg,
 			isMounted,
-			deadProjects,
-			isOwned: (device) => device.kind === "ios" ? isStimOwnedSim({
-				udid: device.id,
-				name: device.name
-			}) : isStimOwnedAvdName(device.id, ownedAvdDirectory(device.id) ?? orphanedAvdDirectories.find((entry) => entry.name === device.id)?.directory ?? null)
+			deadProjects
+		});
+		unverifiedDevices = found.unverified.flatMap((device) => {
+			const directories = device.kind === "android" && !registeredAvds.has(device.id) ? orphanedAvdDirectories.filter((entry) => entry.name === device.id) : [];
+			return directories.length ? directories.map(({ directory }) => Object.assign({}, device, { directory })) : [device];
 		});
-		unverifiedDevices = found.unverified;
 		orphanedDevices = withAndroidAvdSizes(found.orphaned.flatMap((device) => {
 			const directories = device.kind === "android" ? orphanedAvdDirectories.filter((entry) => entry.name === device.name) : [];
 			return directories.length ? directories.map((orphanedDirectory) => Object.assign({}, device, { orphanedDirectory })) : [device];
@@ -1215,6 +2053,7 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 	}
 	const locks = listBuildLocks();
 	const slots = listBuildSlots();
+	const goneWorkspaceDirs = [...workspaceDirs.orphaned.map((entry) => entry.dir), ...deadProjects.map(workspaceDir)];
 	const deviceLeases = collectDeviceLeases(now);
 	return {
 		skipped,
@@ -1232,6 +2071,7 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 		unverifiedDevices,
 		staleDevices,
 		staleDeviceRecords,
+		staleLedgerEntries,
 		buildLocks: {
 			stale: locks.filter((l) => !l.alive && !l.unresolved),
 			live: locks.filter((l) => l.alive),
@@ -1250,9 +2090,10 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 		workspaceOutputs: collectWorkspaceOutputs({
 			olderThan,
 			now,
-			exclude: [...workspaceDirs.orphaned.map((entry) => entry.dir), ...deadProjects.map(workspaceDir)]
+			exclude: goneWorkspaceDirs
 		}),
-		worktreeSweep: collectWorktreeSweep({
+		workspaceLogs: collectWorkspaceLogs({ exclude: goneWorkspaceDirs }),
+		worktreeSweep: await collectWorktreeSweep({
 			idle: worktrees,
 			olderThan,
 			now
@@ -1341,7 +2182,7 @@ async function sweep(opts, deps) {
 	try {
 		easSessionSweep = await withProjectLock(projectRoot, () => {
 			sweepStarted = true;
-			return withRemoteSessionGcLocks(projectRoot, deps, (coordinatedDeps) => Promise.resolve(collectEasSessionSweep(loadConfig(), coordinatedDeps)));
+			return withRemoteSessionGcLocks(projectRoot, deps, (coordinatedDeps) => Promise.resolve(collectEasSessionSweep(loadConfig$1(), coordinatedDeps)));
 		}, {
 			waitMs: 0,
 			ownerPurpose: "EAS orphan sweep",
@@ -1360,7 +2201,51 @@ async function sweep(opts, deps) {
 		precollectedEasSessionSweep: easSessionSweep
 	});
 }
+async function pruneDeadProjects(deadProjects) {
+	let deleteFailures = 0;
+	for (const path of deadProjects) {
+		if (existsSync$1(path) || !isOnMountedVolume(path)) {
+			console.log(chalk.yellow(`Kept ${path}: its absence can no longer be confirmed.`));
+			recordGcResult("project", "kept", path, { detail: "its absence can no longer be confirmed" });
+			continue;
+		}
+		const result = await reclaimProject(path).catch((error) => {
+			deleteFailures++;
+			console.log(chalk.red(`Could not prune ${path}; its registry entry was kept: ${error.message}`));
+			recordGcResult("project", "failed", path, { detail: `its registry entry was kept: ${error.message}` });
+			return null;
+		});
+		if (!result) continue;
+		if (result.keptEntry) {
+			console.log(chalk.yellow(`Could not fully prune ${path}; its registry entry was kept.`));
+			recordGcResult("project", "kept", path, { detail: "it could not be fully pruned; its registry entry was kept" });
+		} else {
+			console.log(chalk.green(`Pruned ${path}`));
+			recordGcResult("project", "done", path);
+		}
+		for (const dir of result.removedWorkspaceDirs) console.log(chalk.dim(`  removed workspace output ${dir}`));
+		for (const dir of result.failedWorkspaceDirs) {
+			console.log(chalk.red(`  could not remove workspace output ${dir}`));
+			recordGcResult("workspaceDirectory", "failed", dir, { detail: `could not remove it while pruning ${path}` });
+			deleteFailures += 1;
+		}
+		if (result.killedPid) console.log(chalk.dim(`  killed orphaned Metro pid ${result.killedPid}`));
+		if (result.stoppedSession) console.log(chalk.dim(`  stopped remote session ${result.stoppedSession}`));
+		if (result.stoppedTunnel) console.log(chalk.dim(`  stopped ${result.stoppedTunnel} tunnel`));
+		for (const name of result.deletedDevices) recordGcResult("device", "done", name);
+		for (const s of result.skippedDevices) {
+			console.log(chalk.yellow(`  ${s.name}: ${s.reason}`));
+			recordGcResult("device", result.failedDevices.includes(s) ? "failed" : "kept", s.name, {
+				id: s.udid ?? null,
+				detail: s.reason
+			});
+		}
+		deleteFailures += result.failedDevices.length;
+	}
+	return deleteFailures;
+}
 async function runGcCore(opts, deps) {
+	takeGcResults();
 	const olderThan = typeof opts.olderThan === "number" ? opts.olderThan : null;
 	const cache = typeof opts.cache === "string" && opts.cache.trim() ? opts.cache : null;
 	const report = await collectGcReport({
@@ -1383,10 +2268,11 @@ async function runGcCore(opts, deps) {
 	const all = report.all;
 	for (const line of formatGcReport(report)) console.log(line);
 	const { deadProjects, invalidProjects, orphanedDevices, staleDevices, staleDeviceRecords, buildLocks, buildSlots, deviceLeases, easSessionSweep, caches } = report;
-	const actionable = deadProjects.length + invalidProjects.length > 0 || report.orphanedWorkspaces.length > 0 || Boolean(report.workspaceOutputs?.workspaces.some((entry) => entry.willClear)) || Boolean(report.worktreeSweep?.worktrees.some((entry) => !entry.skipped)) || report.parkedSims.length > 0 || report.parkedAvds.length > 0 || orphanedDevices.length > 0 || staleDevices.length > 0 || staleDeviceRecords.length > 0 || buildLocks.stale.length > 0 || buildSlots.stale.length > 0 || deviceLeases.expired.length > 0 || easSessionSweep.orphaned.length > 0 || (olderThan !== null || all) && caches.length > 0;
+	const actionable = deadProjects.length + invalidProjects.length > 0 || report.orphanedWorkspaces.length > 0 || Boolean(report.workspaceOutputs?.workspaces.some((entry) => entry.willClear)) || report.workspaceLogs.some((entry) => entry.willTrim) || Boolean(report.worktreeSweep?.worktrees.some((entry) => !entry.skipped)) || report.parkedSims.length > 0 || report.parkedAvds.length > 0 || orphanedDevices.length > 0 || staleDevices.length > 0 || staleDeviceRecords.length > 0 || report.staleLedgerEntries.length > 0 || buildLocks.stale.length > 0 || buildSlots.stale.length > 0 || deviceLeases.expired.length > 0 || easSessionSweep.orphaned.length > 0 || (olderThan !== null || all) && caches.length > 0;
 	const idle = opts.idle ?? null;
-	const idleFailures = idle === null ? 0 : shutDownIdleDevices(report.idleDevices, idle, () => collectIdleDevices(loadConfig(), listAllIosSims({ timeoutMs: DEVICE_LIST_TIMEOUT_MS }), report.deadProjects)).failures;
+	const idleFailures = idle === null ? 0 : shutDownIdleDevices(report.idleDevices, idle, () => collectIdleDevices(loadConfig$1(), listAllIosSims({ timeoutMs: DEVICE_LIST_TIMEOUT_MS }), report.deadProjects)).failures;
 	if (idleFailures) process.exitCode = 1;
+	const inventory = opts.json && !opts.delete && idle === null && report.cacheScope === null ? collectInventory(loadConfig$1(), deadProjects) : null;
 	const payload = (failures) => ({
 		mode: opts.delete ? "delete" : "dry-run",
 		idle,
@@ -1395,7 +2281,9 @@ async function runGcCore(opts, deps) {
 		worktreeSweep: report.worktreeSweep?.idle ?? null,
 		actionable,
 		failures,
-		sections: gcReportSections(report)
+		sections: gcReportSections(report),
+		results: takeGcResults(),
+		inventory
 	});
 	if (!opts.delete) {
 		if (all) console.log(chalk.dim("\nDry run. Re-run with --delete to empty the caches above."));
@@ -1405,34 +2293,13 @@ async function runGcCore(opts, deps) {
 	}
 	let deleteFailures = idleFailures;
 	deleteFailures += report.workspaceOutputs ? (await clearWorkspaceOutputs(report.workspaceOutputs, { olderThan })).failures : 0;
+	deleteFailures += await trimWorkspaceLogs(report.workspaceLogs);
 	deleteFailures += deleteParkedSims(report.parkedSims, deps) + deleteParkedAvds(report.parkedAvds);
 	removeInvalidProjectEntries(invalidProjects);
-	for (const path of deadProjects) {
-		if (existsSync(path) || !isOnMountedVolume(path)) {
-			console.log(chalk.yellow(`Kept ${path}: its absence can no longer be confirmed.`));
-			continue;
-		}
-		const result = await reclaimProject(path).catch((error) => {
-			deleteFailures++;
-			console.log(chalk.red(`Could not prune ${path}; its registry entry was kept: ${error.message}`));
-			return null;
-		});
-		if (!result) continue;
-		if (result.keptEntry) console.log(chalk.yellow(`Could not fully prune ${path}; its registry entry was kept.`));
-		else console.log(chalk.green(`Pruned ${path}`));
-		for (const dir of result.removedWorkspaceDirs) console.log(chalk.dim(`  removed workspace output ${dir}`));
-		for (const dir of result.failedWorkspaceDirs) {
-			console.log(chalk.red(`  could not remove workspace output ${dir}`));
-			deleteFailures += 1;
-		}
-		if (result.killedPid) console.log(chalk.dim(`  killed orphaned Metro pid ${result.killedPid}`));
-		if (result.stoppedSession) console.log(chalk.dim(`  stopped remote session ${result.stoppedSession}`));
-		if (result.stoppedTunnel) console.log(chalk.dim(`  stopped ${result.stoppedTunnel} tunnel`));
-		for (const s of result.skippedDevices) console.log(chalk.yellow(`  ${s.name}: ${s.reason}`));
-		deleteFailures += result.failedDevices.length;
-	}
+	deleteFailures += await pruneDeadProjects(deadProjects);
 	deleteFailures += await deleteOrphanedWorkspaces(report.orphanedWorkspaces);
 	deleteFailures += deleteProjectDevices(orphanedDevices, staleDevices, staleDeviceRecords);
+	deleteFailures += forgetStaleLedgerEntries(report.staleLedgerEntries);
 	for (const lock of buildLocks.stale) {
 		const cleared = (0, ownership_claim_exports.clearFreeClaimSet)({
 			root: lock.path,
@@ -1441,13 +2308,22 @@ async function runGcCore(opts, deps) {
 		if (cleared.status === "held") continue;
 		if (cleared.status === "refused") {
 			console.log(chalk.yellow(`Left the build lock at ${lock.path} alone: ${cleared.reason}`));
+			recordGcResult("buildLock", "kept", `${lock.platform} build lock`, {
+				id: lock.path,
+				detail: cleared.reason
+			});
 			continue;
 		}
 		if (cleared.status === "failed") {
 			deleteFailures++;
 			console.log(chalk.red(`Failed to clear the build lock at ${lock.path}: ${cleared.reason}`));
+			recordGcResult("buildLock", "failed", `${lock.platform} build lock`, {
+				id: lock.path,
+				detail: cleared.reason
+			});
 			continue;
 		}
+		recordGcResult("buildLock", "done", `${lock.platform} build lock`, { id: lock.path });
 		console.log(chalk.green(`Cleared the ${lock.platform} build lock left by pid ${lock.pid ?? "?"} (${lock.projectRoot || "unrecorded workspace"})`));
 	}
 	for (const slot of buildSlots.stale) {
@@ -1458,21 +2334,36 @@ async function runGcCore(opts, deps) {
 		if (cleared.status === "held") continue;
 		if (cleared.status === "refused") {
 			console.log(chalk.yellow(`Left the build slot at ${slot.path} alone: ${cleared.reason}`));
+			recordGcResult("buildSlot", "kept", `build slot ${slot.index ?? "?"}`, {
+				id: slot.path,
+				detail: cleared.reason
+			});
 			continue;
 		}
 		if (cleared.status === "failed") {
 			deleteFailures++;
 			console.log(chalk.red(`Failed to clear the build slot at ${slot.path}: ${cleared.reason}`));
+			recordGcResult("buildSlot", "failed", `build slot ${slot.index ?? "?"}`, {
+				id: slot.path,
+				detail: cleared.reason
+			});
 			continue;
 		}
+		recordGcResult("buildSlot", "done", `build slot ${slot.index ?? "?"}`, { id: slot.path });
 		console.log(chalk.green(`Cleared build slot ${slot.index ?? "?"} left by pid ${slot.pid ?? "?"} (${slot.projectRoot || "unrecorded workspace"})`));
 	}
 	for (const entry of deviceLeases.expired) try {
-		if (removeExpiredLease(entry)) console.log(chalk.green(`Cleared the expired ${entry.platform} device lease on ${entry.id ?? entry.name} (held by ${entry.lease?.holder ?? "an unrecorded workspace"})`));
-		else console.log(chalk.dim(`${entry.name} is no longer an expired lease; left alone.`));
+		if (removeExpiredLease(entry)) {
+			recordGcResult("deviceLease", "done", `${entry.platform} lease on ${entry.id ?? entry.name}`, { id: entry.path });
+			console.log(chalk.green(`Cleared the expired ${entry.platform} device lease on ${entry.id ?? entry.name} (held by ${entry.lease?.holder ?? "an unrecorded workspace"})`));
+		} else console.log(chalk.dim(`${entry.name} is no longer an expired lease; left alone.`));
 	} catch (err) {
 		deleteFailures++;
 		console.log(chalk.red(`Failed to clear the device lease at ${entry.path}: ${err?.message || err}`));
+		recordGcResult("deviceLease", "failed", `${entry.platform} lease on ${entry.id ?? entry.name}`, {
+			id: entry.path,
+			detail: err?.message || String(err)
+		});
 	}
 	deleteFailures += await deleteEasSessions(easSessionSweep, deps);
 	if (report.worktreeSweep) deleteFailures += await removeWorktrees(report.worktreeSweep);
@@ -1487,7 +2378,7 @@ async function runGcCore(opts, deps) {
 	return payload(deleteFailures);
 }
 function gcCommand(program) {
-	program.command("gc").description("Report what Stim has left behind: dead project entries, orphaned workspace directories, clean Stim-managed linked worktrees whose branch is merged, orphaned owned devices and EAS sessions, records of devices that no longer exist, build locks whose builder is gone, expired physical-device leases, the shared build caches, and the build outputs of each workspace. Reports by default; pass --delete to act.").option("--worktrees", "also remove clean, idle Stim-managed linked worktrees, not only merged ones: with --delete run `stim worktree remove` (never --force) on each; idle means unused for --older-than days, 7 without it").option("--delete", "actually prune the reported entries, reap the reported devices, and clear the build outputs of every workspace not in use").option("--older-than <days>", "also reap owned devices whose workspace has not been used this long, trim shared cache entries nothing has used in that time, and clear workspace build outputs only for workspaces idle this long and parked devices only once parked this long", (v) => {
+	program.command("gc").description("Report what Stim has left behind: dead project entries, orphaned workspace directories, clean Stim-managed linked worktrees whose branch is merged or whose pull request was merged or closed, orphaned owned devices and EAS sessions, records of devices that no longer exist, build locks whose builder is gone, expired physical-device leases, the shared build caches, and the build outputs and logs of each workspace. Reports by default; pass --delete to act.").option("--worktrees", "also remove clean, idle Stim-managed linked worktrees, not only merged ones: with --delete run `stim worktree remove` (never --force) on each; idle means unused for --older-than days, 7 without it").option("--delete", "actually prune the reported entries, reap the reported devices, clear the build outputs of every workspace not in use, and trim its Metro, client and device logs to their newest 8 MiB").option("--older-than <days>", "also reap owned devices whose workspace has not been used this long, trim shared cache entries nothing has used in that time, and clear workspace build outputs only for workspaces idle this long and parked devices only once parked this long", (v) => {
 		const n = parseInt(v, 10);
 		if (!Number.isFinite(n) || String(n) !== String(v).trim()) throw new InvalidArgumentError("must be a whole number of days, e.g. --older-than 30");
 		return n;