stim 1.15.0 → 1.17.0

package/dist/{worktree-qXKzADSC.mjs → worktree-ZpZR3S1k.mjs}

@@ -2,37 +2,485 @@ import { t as getExecutor } from "./exec-CaErVv7t.mjs";
 import { E as upsertProject, H as projectDeviceSlots, S as removeProject, _ as loadConfig$1, a as clearDevice, d as getConfigDir, g as isPathPrefix, k as acquireAvdClaim, p as getProject } from "./config-D0DbpZtM.mjs";
 import { n as ownership_claim_exports, t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
 import { a as pullRequestLookup, r as endedPullRequest } from "./pull-request-pxnDCQzn.mjs";
-import { b as workspaceDir, i as recordWorkspaceUse, r as readWorkspaceState$1 } from "./workspace-state-CL2V2Ons.mjs";
-import { C as sourceCheckoutOf, S as restoreFile, T as warmWorktreePaths, _ as readWorktreeExclude, b as resolveFullRef, d as hasUncommittedWork, f as isPodInstallChurn, g as podsOutOfSync, h as locallyKnownUpstream, i as depsOutOfSync, l as hasPopulatedSubmodules, m as listWorktrees, n as cloneIgnoredEntries, o as dirtyPaths, r as deleteBranch, s as gitCommonDir, t as branchExists, u as hasRemote, v as removeWorktree, w as unpushedCommits } from "./worktree-C0c5Udwa.mjs";
-import { a as findProjectRoot$1, n as appProjectProblem } from "./project-CV3tDFHl.mjs";
-import { a as clearRemoteSession, c as readMetroTunnel, d as readRemoteSessionId, i as clearManagedMetroTunnel, u as readRemoteSession } from "./state-CaeaHbDA.mjs";
-import { a as formatElapsed, h as shortUdid, i as formatDuration, l as phaseLine, p as releasedLeaseFact, u as plural } from "./command-output-CliHHn7a.mjs";
-import { u as releaseWorkspaceLeases } from "./device-lease-W5Pi1q38.mjs";
+import { a as formatElapsed, h as shortUdid, i as formatDuration, l as phaseLine, p as releasedLeaseFact, u as plural } from "./command-output-CDAIFD-8.mjs";
+import { $ as cloneIgnoredEntries, A as readCommittedSettings, H as unknownSettingKeys, P as resolveSettings, Q as branchExists, R as settingShapeErrors, St as warmWorktreePaths, _t as resolveFullRef, at as gitCommonDirOnDisk, bt as sourceCheckoutOf, ct as hasUncommittedWork, dt as listWorktrees, et as deleteBranch, ft as locallyKnownUpstream, ht as removeWorktree, i as SETTING_SHAPE_REMEDY, it as gitCommonDir, lt as isPodInstallChurn, mt as readWorktreeExclude, ot as hasPopulatedSubmodules, pt as podsOutOfSync, rt as dirtyPaths, st as hasRemote, tt as depsOutOfSync, xt as unpushedCommits, yt as restoreFile } from "./settings-Cfd-0r2d.mjs";
+import { n as appProjectProblem, s as findProjectRoot$1 } from "./project-D47Rh0ly.mjs";
+import { l as resolveProjectMetro, o as pidExists, r as killMetroTree, u as signalProcessTree } from "./metro-g8NqiJp-.mjs";
+import { g as workspaceAgentDeviceDir, i as recordWorkspaceUse, r as readWorkspaceState$1, v as workspaceDir } from "./workspace-state-DqcCbpE7.mjs";
+import { o as readWebRecord } from "./state-PeQiJuIu.mjs";
+import { a as machineNumber } from "./budget-DM984mnd.mjs";
+import { n as withIdleWorkspace, t as emptyWorkspaceDir } from "./in-use-CvGOUn-x.mjs";
+import { t as agentDeviceDaemon } from "./activity-IRvJY_ru.mjs";
+import { u as releaseWorkspaceLeases } from "./device-lease-DpoS36_u.mjs";
+import { a as clearRemoteSession, c as readMetroTunnel, d as readRemoteSessionId, i as clearManagedMetroTunnel, u as readRemoteSession } from "./state-BKa8wNN5.mjs";
+import { ft as parkedMaxSetting, ot as POOL_SETTING_REMEDY } from "./android-B_YNZy61.mjs";
 import { a as workspaceLinks, i as workspaceLinkLine } from "./stim-desktop-Cnz8CPnl.mjs";
-import { at as POOL_SETTING_REMEDY, dt as parkedMaxSetting } from "./android-Db2eEMaf.mjs";
-import { l as resolveProjectMetro, o as pidExists, r as killMetroTree, u as signalProcessTree } from "./metro-Di8EN2Tb.mjs";
-import { B as unknownSettingKeys, L as settingShapeErrors, N as resolveSettings, a as SETTING_SHAPE_REMEDY } from "./settings-CduVcoxj.mjs";
-import { a as teardownOwnedBrowser, i as teardownOwnedAvd, o as teardownOwnedIosSim } from "./teardown-BYuQafiA.mjs";
-import { t as clearNamedPorts } from "./named-ports-Dj_XBNaL.mjs";
-import { o as readWebRecord } from "./state-DFm77wRn.mjs";
-import { n as withIdleWorkspace, t as emptyWorkspaceDir } from "./in-use-CndPMilN.mjs";
-import { g as withManagedRemoteWorktreeRemovalLock, l as withdrawDevServerStopRequest, p as stopTunnel, s as requestDevServerStop, u as resolveSupervisorTarget, v as withManagedTunnelRemovalLock } from "./stop-cause-CZ_Mr-v9.mjs";
-import { n as verifyCollectorOwnership } from "./ownership-BkYxUtuj.mjs";
-import { C as podInstallCommand, u as HEARTBEAT_INTERVAL_MS } from "./toolchain-DmeYjXD9.mjs";
-import { t as stopMacosApp } from "./stop-Bvf1MflS.mjs";
-import { a as runPodInstall, i as runCaptured, n as podsAreStale, r as readPodState, t as DEPS_ERROR } from "./deps-BFlKbOIp.mjs";
-import { f as resolveEasCliBin } from "./remote-cache-CO2elm_b.mjs";
-import { i as endRecordedSession } from "./device-remote-9ulPsdhY.mjs";
-import { n as hasInstalledDependencies, r as installedNpmTreeIsValid, t as dependencyState } from "./dependency-state-BmsjKZ2H.mjs";
-import { a as forgetStatusMeasures, t as startWarmProgress } from "./warm-progress-DVHLN4uC.mjs";
+import { g as teardownOwnedIosSim, h as teardownOwnedBrowser, i as stopTunnel, l as withManagedTunnelRemovalLock, m as teardownOwnedAvd, s as withManagedRemoteWorktreeRemovalLock, t as resolveSupervisorTarget } from "./ownership-BMLqyBgJ.mjs";
+import { t as clearNamedPorts } from "./named-ports-C8m8EQs2.mjs";
+import { l as withdrawDevServerStopRequest, s as requestDevServerStop } from "./stop-cause-rhmGfwvt.mjs";
+import { C as podInstallCommand, u as HEARTBEAT_INTERVAL_MS } from "./toolchain-CNIBTIOv.mjs";
+import { n as verifyCollectorOwnership } from "./ownership-DyRQru0q.mjs";
+import { t as stopMacosApp } from "./stop-Cr1d8DSE.mjs";
+import { a as runPodInstall, i as runCaptured, n as podsAreStale, r as readPodState, t as DEPS_ERROR } from "./deps-DNWaQs4V.mjs";
+import { i as stopHostedAndroid } from "./hosted-android-DwLS4Mse.mjs";
+import { f as resolveEasCliBin } from "./remote-cache-Ci4DQYYj.mjs";
+import { i as endRecordedSession } from "./device-remote-hFSkpfQu.mjs";
+import { n as hasInstalledDependencies, r as installedNpmTreeIsValid, t as dependencyState } from "./dependency-state-CLcBHH2M.mjs";
+import { a as forgetStatusMeasures, s as mergeState, t as startWarmProgress } from "./warm-progress-DF4JRvYI.mjs";
+import { r as workspaceRecordingEnabled } from "./recordings-BNgsD1Tr.mjs";
+import { r as stopHostedIos } from "./hosted-ios-aMo7Cljf.mjs";
 import { createHash, randomUUID } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { join, relative } from "node:path";
+import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, utimesSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, relative } from "node:path";
 import { existsSync as existsSync$1, realpathSync as realpathSync$1, rmSync as rmSync$1 } from "fs";
 import { basename as basename$1, dirname as dirname$1, isAbsolute as isAbsolute$1, join as join$1, relative as relative$1, resolve as resolve$1 } from "path";
-import { workspaceName } from "@stim-cli/core";
-import { LAST_BUILD_KEYS, readMacosRecord } from "@stim-cli/core/state";
+import { withDirLock, workspaceName } from "@stim-cli/core";
+import { LAST_BUILD_KEYS, archiveDir, archiveEnabled, archiveLock, archiveRoot, archivedUsage, countErrorEntries, endedAgentSessionOf, listRecordedDevices, loadConfig, queryLogs, readArchives, readBuildHistory, readJsonObject, readLastBuilds, readMacosRecord, readPullRequestCache, readWorkspaceState, recordingEnabled, sortByTs } from "@stim-cli/core/state";
+import { claimRemoveCommand, clearFreeClaimSet, readClaimSet, releaseClaim, tryAcquireClaim } from "@stim-cli/core/ownership-claim";
+import { homedir } from "node:os";
 import chalk from "chalk";
+//#region src/archive.ts
+const DAY = 864e5;
+const KINDS = [
+	"logs",
+	"recordings",
+	"agentActions"
+];
+const KIND_PATH = {
+	logs: "logs",
+	recordings: "recordings",
+	agentActions: "agent-device/sessions"
+};
+function archiveSettings() {
+	const config = loadConfig();
+	return Object.fromEntries([
+		"maxAgeDays",
+		"maxCount",
+		"maxTotalGb",
+		"logs.maxAgeDays",
+		"logs.maxMbPerWorkspace",
+		"recordings.maxAgeDays",
+		"recordings.maxTotalGb",
+		"agentActions.maxAgeDays"
+	].map((key) => {
+		const result = machineNumber(`archive.${key}`, config, process.env);
+		if (result.error) throw new Error(result.error);
+		return [key, result.value];
+	}));
+}
+function enabled(root) {
+	const config = loadConfig();
+	const project = config?.projects?.[root];
+	const present = existsSync(root);
+	const common = present ? gitCommonDirOnDisk(root) : null;
+	if (!present && Object.values(config?.repos ?? {}).some((repo) => repo.settings?.archive?.enabled === false)) return false;
+	return archiveEnabled(process.env, [
+		project?.settings,
+		common ? config?.repos?.[common]?.settings : void 0,
+		present ? readCommittedSettings(root) : void 0,
+		config
+	]);
+}
+function files(dir) {
+	if (!existsSync(dir)) return [];
+	return readdirSync(dir).flatMap((name) => {
+		const path = join(dir, name);
+		const stat = lstatSync(path);
+		if (stat.isSymbolicLink()) throw new Error(`refusing symlink ${path}`);
+		return stat.isDirectory() ? files(path) : [{
+			path,
+			bytes: stat.size,
+			at: stat.mtimeMs
+		}];
+	});
+}
+function secureTree(dir) {
+	if (lstatSync(dir).isSymbolicLink()) throw new Error(`refusing symlink ${dir}`);
+	chmodSync(dir, 448);
+	for (const name of readdirSync(dir)) {
+		const path = join(dir, name);
+		const stat = lstatSync(path);
+		if (stat.isSymbolicLink()) throw new Error(`refusing symlink ${path}`);
+		if (stat.isDirectory()) secureTree(path);
+		else chmodSync(path, 384);
+	}
+}
+function writeRecord(dir, record) {
+	const small = [
+		"state.json",
+		"ended-agents.json",
+		"log-error-index.json"
+	].reduce((sum, name) => {
+		const path = join(dir, name);
+		return sum + (existsSync(path) ? statSync(path).size : 0);
+	}, 0);
+	for (let pass = 0; pass < 8; pass++) {
+		record.bytes.total = KINDS.reduce((sum, kind) => sum + record.bytes[kind], record.bytes.record);
+		const bytes = small + Buffer.byteLength(`${JSON.stringify(record)}\n`);
+		if (bytes === record.bytes.record) break;
+		record.bytes.record = bytes;
+	}
+	record.bytes.total = KINDS.reduce((sum, kind) => sum + record.bytes[kind], record.bytes.record);
+	const tmp = join(dir, `.archive-${randomUUID()}.tmp`);
+	try {
+		writeFileSync(tmp, `${JSON.stringify(record)}\n`, { mode: 384 });
+		renameSync(tmp, join(dir, "archive.json"));
+	} finally {
+		rmSync(tmp, { force: true });
+	}
+	const now = /* @__PURE__ */ new Date();
+	utimesSync(archiveRoot(), now, now);
+}
+function removeRecord(id) {
+	const dir = archiveDir(id);
+	if (!existsSync(dir)) return;
+	const removing = join(archiveRoot(), `.removing-${id}`);
+	renameSync(dir, removing);
+	rmSync(removing, {
+		recursive: true,
+		force: true
+	});
+}
+function sweepArchiveStaging(remove, waitMs = 0) {
+	if (!existsSync(archiveRoot())) return [];
+	return withDirLock(archiveLock(), () => readdirSync(archiveRoot()).filter((name) => name.startsWith(".incoming-") && (!name.endsWith(".claims") || !existsSync(join(archiveRoot(), name.slice(0, -7)))) || name.startsWith(".removing-")).flatMap((name) => {
+		const path = join(archiveRoot(), name.endsWith(".claims") ? name.slice(0, -7) : name);
+		const root = `${path}.claims`;
+		const survey = name.startsWith(".incoming-") ? readClaimSet(root) : null;
+		const unresolved = survey?.unresolved[0];
+		const kept = Boolean(survey && (survey.live.length || survey.unresolved.length));
+		const entry = {
+			path,
+			kept,
+			reason: unresolved?.reason ?? (kept ? "live archive writer" : null),
+			removeCommand: unresolved ? claimRemoveCommand(root) : null
+		};
+		if (remove && !kept) {
+			if (!survey || clearFreeClaimSet({
+				root,
+				label: "archive staging"
+			}).status === "cleared") {
+				rmSync(path, {
+					recursive: true,
+					force: true
+				});
+				return [];
+			}
+		}
+		return [entry];
+	}), { waitMs });
+}
+function stripPids(value) {
+	if (Array.isArray(value)) return value.map(stripPids);
+	if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).filter(([key]) => !/pids?$/i.test(key)).map(([key, child]) => [key, stripPids(child)]));
+	return value;
+}
+function gitFacts(root) {
+	const empty = {
+		repository: null,
+		branch: null,
+		head: null,
+		subject: null,
+		merged: null,
+		pullRequest: null
+	};
+	if (!existsSync(root)) return cachedFacts(root) ?? empty;
+	const exec = getExecutor();
+	const run = (args) => exec.runFileQuiet("git", [
+		"-C",
+		root,
+		...args
+	], { timeoutMs: 1e3 });
+	const common = gitCommonDirOnDisk(root);
+	const summary = run([
+		"show",
+		"-s",
+		"--format=%H%n%s",
+		"HEAD"
+	])?.split("\n");
+	const location = run([
+		"rev-parse",
+		"--show-toplevel",
+		"--abbrev-ref",
+		"HEAD"
+	])?.split("\n");
+	const branch = location?.[1] && location[1] !== "HEAD" ? location[1] : null;
+	const defaultRef = run([
+		"symbolic-ref",
+		"--quiet",
+		"refs/remotes/origin/HEAD"
+	]);
+	let merged = null;
+	if (defaultRef?.startsWith("refs/remotes/")) {
+		const state = mergeState(root, {
+			ref: defaultRef,
+			name: defaultRef.slice(13)
+		}, { timeoutMs: 2e3 });
+		merged = state.merged ? true : state.unknown ? null : false;
+	}
+	let prPath = root;
+	try {
+		if (location?.[0]) prPath = realpathSync(location[0]);
+	} catch {}
+	const pr = readPullRequestCache(prPath)?.pullRequest;
+	if (pr?.state === "merged") merged = true;
+	return {
+		repository: common ? basename(common) === ".git" ? dirname(common) : common : null,
+		branch,
+		head: summary?.[0] ?? null,
+		subject: summary?.[1] ?? null,
+		merged,
+		pullRequest: archivedPullRequest(pr)
+	};
+}
+function archivedPullRequest(pr) {
+	return pr ? {
+		number: pr.number,
+		state: pr.state,
+		title: pr.title,
+		url: pr.url
+	} : null;
+}
+function cachedFacts(root) {
+	for (let path = root; !existsSync(path); path = dirname(path)) {
+		const cached = readPullRequestCache(path);
+		if (!cached) continue;
+		return {
+			repository: null,
+			branch: cached.branch,
+			head: cached.head,
+			subject: null,
+			merged: cached.pullRequest?.state === "merged" ? true : null,
+			pullRequest: archivedPullRequest(cached.pullRequest)
+		};
+	}
+	return null;
+}
+function archiveWorkspace(root, removedBy, state = readWorkspaceState(root)) {
+	writeArchive(root, removedBy, state);
+	try {
+		enforceArchiveRetention();
+	} catch (error) {
+		console.error(`could not enforce archive retention: ${String(error?.message ?? error).split("\n")[0]}`);
+	}
+}
+function writeArchive(root, removedBy, state) {
+	let staging = null;
+	let claim;
+	try {
+		const dir = workspaceDir(root);
+		if (!existsSync(dir) || lstatSync(dir).isSymbolicLink()) return;
+		if (existsSync(root)) root = realpathSync(root);
+		try {
+			sweepArchiveStaging(true, 5e3);
+		} catch {}
+		if (!enabled(root)) return;
+		const limits = archiveSettings();
+		if (!limits.maxAgeDays || !limits.maxCount) return;
+		const logs = join(dir, "logs");
+		if (!existsSync(join(dir, "state.json")) && !Object.values(readBuildHistory(state)).some((entries) => entries?.length) && (!existsSync(logs) || readdirSync(logs).length === 0)) return;
+		const worktree = gitFacts(root);
+		mkdirSync(archiveRoot(), {
+			recursive: true,
+			mode: 448
+		});
+		chmodSync(archiveRoot(), 448);
+		const token = randomUUID();
+		staging = join(archiveRoot(), `.incoming-${token}`);
+		const attempt = tryAcquireClaim({
+			root: `${staging}.claims`,
+			mode: "exclusive",
+			label: "archive staging"
+		});
+		claim = attempt.acquired;
+		if (!claim) {
+			releaseClaim(attempt.pending);
+			throw new Error("archive staging claim is held");
+		}
+		withDirLock(archiveLock(), () => {
+			mkdirSync(staging, { mode: 448 });
+			let at = Date.now();
+			const workspace = workspaceName(root);
+			while (existsSync(archiveDir(`${workspace}--${at}`))) at++;
+			const id = `${workspace}--${at}`;
+			if (state) {
+				const { supervisor: _supervisor, collectors: _collectors, warm: _warm, ...stable } = state;
+				writeFileSync(join(staging, "state.json"), `${JSON.stringify(stripPids(stable))}\n`, { mode: 384 });
+			}
+			for (const name of ["ended-agents.json", "log-error-index.json"]) {
+				const data = readJsonObject(join(dir, name));
+				if (data) writeFileSync(join(staging, name), `${JSON.stringify(stripPids(data))}\n`, { mode: 384 });
+			}
+			const move = (kind) => {
+				const from = join(dir, KIND_PATH[kind]);
+				if (!limits[`${kind}.maxAgeDays`] || !existsSync(from)) return;
+				const to = join(staging, KIND_PATH[kind]);
+				mkdirSync(join(to, ".."), {
+					recursive: true,
+					mode: 448
+				});
+				renameSync(from, to);
+				secureTree(to);
+			};
+			move("logs");
+			move("agentActions");
+			const config = loadConfig();
+			if (limits["recordings.maxAgeDays"] && workspaceRecordingEnabled(root, config?.projects?.[root] ?? {}, config, process.env)) {
+				const recordingDir = join(dir, "recordings");
+				if (existsSync(recordingDir) && lstatSync(recordingDir).isSymbolicLink()) throw new Error(`refusing symlink ${recordingDir}`);
+				for (const device of listRecordedDevices(recordingDir)) {
+					if (lstatSync(device.dir).isSymbolicLink()) throw new Error(`refusing symlink ${device.dir}`);
+					const to = join(staging, "recordings", `${device.platform}-${device.slot}`);
+					for (const segment of device.segments.filter((entry) => !entry.open)) {
+						mkdirSync(to, {
+							recursive: true,
+							mode: 448
+						});
+						try {
+							if (lstatSync(segment.file).isSymbolicLink()) throw new Error(`refusing symlink ${segment.file}`);
+							renameSync(segment.file, join(to, basename(segment.file)));
+							chmodSync(join(to, basename(segment.file)), 384);
+						} catch (error) {
+							if (error.code !== "ENOENT") throw error;
+						}
+					}
+				}
+			}
+			const index = readJsonObject(join(staging, "log-error-index.json"));
+			const indexed = Object.values(index?.files ?? {}).flatMap((file) => Object.values(file.markers ?? {}).concat(file.errors ?? []));
+			const lastErrorCount = countErrorEntries(sortByTs(queryLogs({
+				records: indexed,
+				errorsOnly: true
+			})));
+			const history = Object.values(readBuildHistory(state)).flat();
+			const last = Object.values(readLastBuilds(state)).toSorted((a, b) => Date.parse(b.startedAt) - Date.parse(a.startedAt))[0] ?? null;
+			const bytes = {
+				logs: 0,
+				recordings: 0,
+				agentActions: 0,
+				record: 0,
+				total: 0
+			};
+			const expires = {
+				logs: null,
+				recordings: null,
+				agentActions: null,
+				record: new Date(at + limits.maxAgeDays * DAY).toISOString()
+			};
+			for (const kind of KINDS) {
+				bytes[kind] = files(join(staging, KIND_PATH[kind])).reduce((sum, file) => sum + file.bytes, 0);
+				if (bytes[kind]) expires[kind] = new Date(at + limits[`${kind}.maxAgeDays`] * DAY).toISOString();
+			}
+			const record = {
+				id,
+				projectRoot: root,
+				project: basename(root),
+				workspace,
+				worktree,
+				removedAt: new Date(at).toISOString(),
+				removedBy,
+				lastUsedAt: typeof state?.lastUsedAt === "string" ? state.lastUsedAt : null,
+				builds: {
+					count: history.length,
+					last,
+					lastErrorCount
+				},
+				agents: (readJsonObject(join(dir, "ended-agents.json"))?.sessions ?? []).map(endedAgentSessionOf).filter((session) => session !== null),
+				bytes,
+				expires,
+				version: 1
+			};
+			writeRecord(staging, record);
+			renameSync(staging, archiveDir(id));
+		}, { waitMs: 3e4 });
+		releaseClaim(claim);
+		claim = void 0;
+		staging = null;
+	} catch (error) {
+		if (staging) try {
+			rmSync(staging, {
+				recursive: true,
+				force: true
+			});
+		} catch {}
+		console.error(`could not archive: ${String(error?.message ?? error).split("\n")[0]}`);
+	} finally {
+		releaseClaim(claim);
+	}
+}
+function removeKind(record, kind) {
+	rmSync(join(archiveDir(record.id), KIND_PATH[kind]), {
+		recursive: true,
+		force: true
+	});
+	record.bytes[kind] = 0;
+	record.expires[kind] = null;
+	writeRecord(archiveDir(record.id), record);
+}
+function logRemovalOrder(path) {
+	return /\.ndjson\.\d+$/.test(path) ? 0 : /^build-.*\.ndjson$/.test(basename(path)) ? 1 : 2;
+}
+function enforceArchiveRetention(now = Date.now()) {
+	if (!existsSync(archiveRoot())) return;
+	let limits;
+	try {
+		limits = archiveSettings();
+	} catch (error) {
+		console.error(`could not enforce archive retention: ${String(error.message).split("\n")[0]}`);
+		return;
+	}
+	withDirLock(archiveLock(), () => {
+		const listed = readArchives().toReversed();
+		const records = listed.filter((record, index) => limits.maxAgeDays > 0 && now - Date.parse(record.removedAt) < limits.maxAgeDays * DAY && index >= listed.length - limits.maxCount);
+		for (const record of listed) if (!records.includes(record)) removeRecord(record.id);
+		const recordings = recordingEnabled(process.env, [loadConfig()]);
+		for (const record of records) {
+			for (const kind of [
+				"recordings",
+				"agentActions",
+				"logs"
+			]) {
+				const age = limits[`${kind}.maxAgeDays`];
+				if (record.bytes[kind] && (!age || now - Date.parse(record.removedAt) >= age * DAY || kind === "recordings" && !recordings)) removeKind(record, kind);
+			}
+			const cap = limits["logs.maxMbPerWorkspace"] * 1024 ** 2;
+			if (record.bytes.logs > cap) {
+				const entries = files(join(archiveDir(record.id), "logs")).toSorted((a, b) => logRemovalOrder(a.path) - logRemovalOrder(b.path) || (logRemovalOrder(a.path) === 0 ? Number(b.path.split(".").at(-1)) - Number(a.path.split(".").at(-1)) : 0) || a.at - b.at);
+				for (const file of entries) {
+					if (record.bytes.logs <= cap) break;
+					rmSync(file.path);
+					record.bytes.logs = Math.max(0, record.bytes.logs - file.bytes);
+				}
+				if (!record.bytes.logs) record.expires.logs = null;
+				writeRecord(archiveDir(record.id), record);
+			}
+		}
+		const totalCap = limits.maxTotalGb * 1024 ** 3;
+		const recordingCap = limits["recordings.maxTotalGb"] * 1024 ** 3;
+		for (const record of records) for (;;) {
+			const usage = archivedUsage(records);
+			const totalOver = usage.bytes > totalCap;
+			const recordingsOver = usage.byKind.recordings > recordingCap;
+			if (!totalOver && !recordingsOver) break;
+			const candidates = KINDS.filter((kind) => record.bytes[kind] > 0 && (totalOver || kind === "recordings")).toSorted((a, b) => record.bytes[b] - record.bytes[a]);
+			if (!candidates.length) break;
+			removeKind(record, candidates[0]);
+		}
+		for (const record of records) {
+			const before = JSON.stringify(record.expires);
+			for (const kind of KINDS) record.expires[kind] = record.bytes[kind] ? new Date(Date.parse(record.removedAt) + limits[`${kind}.maxAgeDays`] * DAY).toISOString() : null;
+			record.expires.record = new Date(Date.parse(record.removedAt) + limits.maxAgeDays * DAY).toISOString();
+			if (JSON.stringify(record.expires) !== before) writeRecord(archiveDir(record.id), record);
+		}
+	}, { waitMs: 3e4 });
+}
+function deleteSelectedArchives(ids, kind) {
+	withDirLock(archiveLock(), () => {
+		for (const record of readArchives().filter((entry) => ids.includes(entry.id))) if (kind) removeKind(record, kind);
+		else removeRecord(record.id);
+	}, { waitMs: 3e4 });
+}
+//#endregion
 //#region src/devices/reclaim.ts
 async function reapCollectors(root, { verify = verifyCollectorOwnership, collectors }) {
 	const skippedDevices = [];
@@ -288,6 +736,7 @@ async function reclaimProject(path, options = {}) {
 	const existed = existsSync(dir);
 	const run = await withIdleWorkspace(path, () => reclaimIdleProject(path, existed, options), {
 		purpose: "workspace removal",
+		hosted: false,
 		supervisor: false,
 		managedLocks: false
 	});
@@ -316,7 +765,7 @@ async function reclaimProject(path, options = {}) {
 		failedWorkspaceDirs: []
 	};
 }
-async function reclaimIdleProject(path, workspaceExisted, { deleteOwnedDevices = false, parkOwnedDevices = false, preserveProjectRecord = false, stopSession = defaultStopSession, stopMetroTunnel = defaultStopMetroTunnel, releaseLeases = releaseWorkspaceLeases, verifyCollector = verifyCollectorOwnership, teardownBrowser = teardownOwnedBrowser, stopRequester = { by: "stim gc --delete" } }) {
+async function reclaimIdleProject(path, workspaceExisted, { archive, deleteOwnedDevices = false, parkOwnedDevices = false, preserveProjectRecord = false, stopSession = defaultStopSession, stopMetroTunnel = defaultStopMetroTunnel, releaseLeases = releaseWorkspaceLeases, verifyCollector = verifyCollectorOwnership, teardownBrowser = teardownOwnedBrowser, stopRequester = { by: "stim gc --delete" } }) {
 	await clearNamedPorts(path, { stop: true });
 	const project = getProject(path);
 	for (const { platforms } of projectDeviceSlots(project)) if (platforms.android?.owned && platforms.android.avdName) (0, ownership_claim_exports.releaseClaim)(acquireAvdClaim(platforms.android.avdName));
@@ -395,6 +844,17 @@ async function reclaimIdleProject(path, workspaceExisted, { deleteOwnedDevices =
 	};
 	skippedDevices.push(...skippedCollectors);
 	failedDevices.push(...failedCollectors);
+	for (const platform of ["ios", "android"]) try {
+		await (platform === "ios" ? stopHostedIos : stopHostedAndroid)(path);
+	} catch (error) {
+		const failed = {
+			platform,
+			name: `hosted ${platform} device`,
+			reason: error.message
+		};
+		failedDevices.push(failed);
+		skippedDevices.push(failed);
+	}
 	const remote = reclaimRemoteSession(path, { stopSession });
 	if (remote.failed) {
 		skippedDevices.push(remote.failed);
@@ -428,6 +888,28 @@ async function reclaimIdleProject(path, workspaceExisted, { deleteOwnedDevices =
 	if (failedDevices.length === 0 && !supervisorHeld) {
 		const dir = workspaceDir(path);
 		if (existsSync(dir)) try {
+			const stateDir = workspaceAgentDeviceDir(path);
+			if (!["none", "dead"].includes(agentDeviceDaemon(stateDir))) {
+				const exec = getExecutor();
+				try {
+					if (!exec.findExecutable("agent-device")) throw new Error("agent-device is not on PATH");
+					exec.runFile("agent-device", [
+						"daemon",
+						"stop",
+						"--state-dir",
+						stateDir,
+						"--clean"
+					], {
+						timeoutMs: 2e4,
+						killSignal: "SIGKILL",
+						env: { AGENT_DEVICE_NO_UPDATE_NOTIFIER: "1" }
+					});
+				} catch (error) {
+					process.stderr.write(`${phaseLine("agent-device", `daemon could not be stopped: ${error.message}; run agent-device daemon stop --state-dir "${stateDir}" --clean`)}\n`);
+					throw error;
+				}
+			}
+			if (archive) archiveWorkspace(path, archive.removedBy, initialState);
 			emptyWorkspaceDir(dir);
 			if (workspaceExisted) removedWorkspaceDirs.push(dir);
 		} catch {
@@ -457,6 +939,66 @@ async function reclaimIdleProject(path, workspaceExisted, { deleteOwnedDevices =
 	};
 }
 //#endregion
+//#region src/workspace/service-guard.ts
+const SERVICE_IN_USE = { code: "STIM_WORKTREE_SERVICE" };
+function serviceUseOf(plist, file, folder, canonical) {
+	if (typeof plist !== "object" || plist === null) return null;
+	const job = plist;
+	if (typeof job.StimService !== "object" || job.StimService === null || !Array.isArray(job.ProgramArguments)) return null;
+	const argument = job.ProgramArguments.find((value) => typeof value === "string" && value.startsWith("/") && isPathPrefix(folder, canonical(value)));
+	if (argument === void 0) return null;
+	return {
+		label: typeof job.Label === "string" ? job.Label : file,
+		plist: file,
+		argument
+	};
+}
+/** The first installed stim-server service that runs from inside `folder`, or null. macOS only. */
+function serviceRunningFrom(folder, canonical, agentsDir = join(homedir(), "Library", "LaunchAgents")) {
+	if (process.platform !== "darwin") return null;
+	let names;
+	try {
+		names = readdirSync(agentsDir).filter((name) => name.endsWith(".plist"));
+	} catch (error) {
+		return error.code === "ENOENT" ? null : {
+			label: "unknown",
+			plist: agentsDir,
+			argument: null
+		};
+	}
+	for (const name of names) {
+		const file = join(agentsDir, name);
+		const label = name.replace(/\.plist$/, "");
+		try {
+			if (!readFileSync(file).includes("StimService")) continue;
+		} catch {
+			return {
+				label,
+				plist: file,
+				argument: null
+			};
+		}
+		try {
+			const json = getExecutor().runFile("plutil", [
+				"-convert",
+				"json",
+				"-o",
+				"-",
+				file
+			], { timeoutMs: 5e3 });
+			const use = serviceUseOf(JSON.parse(json), file, folder, canonical);
+			if (use) return use;
+		} catch {
+			return {
+				label,
+				plist: file,
+				argument: null
+			};
+		}
+	}
+	return null;
+}
+//#endregion
 //#region src/engine/warm-claim.ts
 const WARM_CLAIM_LABEL = "worktree warm";
 const WARM_CLAIM_POLL_MS = 250;
@@ -1492,7 +2034,7 @@ async function withReclaimLocks(rootPath, fn) {
 	const acquire = (index) => index === keys.length ? fn(keys) : withManagedTunnelRemovalLock(keys[index], () => acquire(index + 1));
 	return acquire(0);
 }
-async function reclaimAll(rootPath, keys = reclaimKeys(rootPath), { preserveRootProject = false } = {}) {
+async function reclaimAll(rootPath, keys = reclaimKeys(rootPath), { preserveRootProject = false, removedBy } = {}) {
 	const dereferenced = [];
 	const killedPids = [];
 	const deletedDevices = [];
@@ -1511,6 +2053,7 @@ async function reclaimAll(rootPath, keys = reclaimKeys(rootPath), { preserveRoot
 		let r;
 		try {
 			r = await reclaimProject(key, {
+				archive: removedBy ? { removedBy } : void 0,
 				deleteOwnedDevices: true,
 				parkOwnedDevices: true,
 				preserveProjectRecord: preserveRootProject && key === rootPath,
@@ -1614,9 +2157,13 @@ function hasRegisteredProjectUnder(rootPath) {
 	const cfg = loadConfig$1();
 	return Object.keys(cfg?.projects ?? {}).some((key) => isPathPrefix(rootPath, key));
 }
+function projectAtOrAbove(root, path) {
+	const here = nativeCanonicalPath(path);
+	return Object.keys(loadConfig$1()?.projects ?? {}).filter((key) => isPathPrefix(nativeCanonicalPath(root), nativeCanonicalPath(key)) && isPathPrefix(nativeCanonicalPath(key), here)).toSorted((a, b) => b.length - a.length)[0] ?? null;
+}
 async function reclaimEnvironment(root, why) {
 	await withManagedRemoteWorktreeRemovalLock(root, () => withReclaimLocks(root, async (lockedKeys) => {
-		const result = await reclaimAll(root, lockedKeys);
+		const result = await reclaimAll(root, lockedKeys, { removedBy: "worktree-remove" });
 		for (const line of poolLines(result)) console.error(line);
 		for (const device of result.deletedDevices) console.error(chalk.dim(phaseLine("device", `deleted ${device}`)));
 		for (const session of result.stoppedSessions) console.error(chalk.dim(phaseLine("device", `stopped remote session ${session}`)));
@@ -1791,7 +2338,18 @@ async function runRemove(target, opts, onRemoved) {
 		return;
 	}
 	if (entry.path === source.path) {
-		if (entry.path !== path) console.error(chalk.dim(`${path} is inside the source checkout ${entry.path}; reclaiming its environment.`));
+		if (nativeCanonicalPath(entry.path) !== nativeCanonicalPath(path)) {
+			const project = projectAtOrAbove(entry.path, path);
+			if (!project) {
+				console.error(chalk.red(`Refusing to reclaim from ${path}: no Stim project is registered at or above it.`));
+				console.error(chalk.dim(`  Run it from the project folder, or from ${entry.path} to reclaim every project under it.`));
+				process.exitCode = 1;
+				return;
+			}
+			console.error(chalk.dim(`${path} is inside the source checkout ${entry.path}; reclaiming only the project ${project}.`));
+			await reclaimEnvironment(project, "it is the source checkout");
+			return;
+		}
 		await reclaimEnvironment(entry.path, "it is the source checkout");
 		return;
 	}
@@ -1805,6 +2363,13 @@ async function runRemove(target, opts, onRemoved) {
 		process.exitCode = 1;
 		return;
 	}
+	const service = serviceRunningFrom(path, nativeCanonicalPath);
+	if (service) {
+		console.error(chalk.red(service.argument ? `Refusing to remove ${path}: it runs the stim-server service ${service.label} (${service.argument}). ${SERVICE_IN_USE.code}` : `Refusing to remove ${path}: could not read ${service.plist} to check whether the stim-server service ${service.label} runs from it. ${SERVICE_IN_USE.code}`));
+		console.error(chalk.dim(`Reinstall the service from another build with \`stim-server service install --label ${service.label}\`, or remove it with \`stim-server service uninstall --label ${service.label}\`, then retry.`));
+		process.exitCode = 1;
+		return;
+	}
 	const project = getProject(path);
 	const branch = entry.branch;
 	const ownsBranch = Boolean(branch && project?.worktreeBranchOwned === true && project.worktreeBranch === branch);
@@ -1835,7 +2400,10 @@ async function runRemove(target, opts, onRemoved) {
 			printRemovalRefusal(path, current);
 			return;
 		}
-		const result = await reclaimAll(path, lockedKeys, { preserveRootProject: true });
+		const result = await reclaimAll(path, lockedKeys, {
+			preserveRootProject: true,
+			removedBy: opts.removedBy ?? "worktree-remove"
+		});
 		if (result.keptEntries.length) {
 			reportRetainedResources(path, result);
 			return;
@@ -1904,7 +2472,7 @@ async function runRemove(target, opts, onRemoved) {
 	}));
 }
 function registerRemove(worktree) {
-	worktree.command("remove [target]").description("Remove a worktree, its unused Stim-created branch, build artifacts, owned devices, and Metro port. Defaults to the current workspace. On the source checkout it reclaims the environment only and leaves the tree in place.").option("--force", "remove even when the worktree holds uncommitted or unpushed work or initialized submodules").action(async (target, opts) => {
+	worktree.command("remove [target]").description("Remove a worktree, its unused Stim-created branch, build artifacts, owned devices, and Metro port. Defaults to the current workspace. On the source checkout it reclaims the environment only and leaves the tree in place; from a subfolder it reclaims only the project at or above that folder, with the projects nested under it.").option("--force", "remove even when the worktree holds uncommitted or unpushed work or initialized submodules").action(async (target, opts) => {
 		await removeWorktreeTarget(target, { force: opts.force });
 	});
 }
@@ -1914,4 +2482,4 @@ function worktreeCommand(program) {
 	registerRemove(worktree);
 }
 //#endregion
-export { porcelainPath as a, registerWarm as c, removalRemedy as d, removeWorktreeTarget as f, reclaimProject as g, describeDereferenced as h, matchWorktreeEntry as i, removalBlockers as l, worktreeCommand as m, excludePodChurn as n, reclaimKeys as o, warmedWorkspace as p, excludeWatchmanCookies as r, registerRemove as s, dependencyInstallCommand as t, removalPath as u };
+export { deleteSelectedArchives as _, porcelainPath as a, registerWarm as c, removalRemedy as d, removeWorktreeTarget as f, reclaimProject as g, describeDereferenced as h, matchWorktreeEntry as i, removalBlockers as l, worktreeCommand as m, excludePodChurn as n, reclaimKeys as o, warmedWorkspace as p, excludeWatchmanCookies as r, registerRemove as s, dependencyInstallCommand as t, removalPath as u, sweepArchiveStaging as v };