@dev.fast/whiteboard 0.2.5-preview.20261013.113 → 0.2.5-preview.20261015.115

package/dist/remote-uninstall-DLtDG0o7.js

@@ -0,0 +1,153 @@
+import { b as REVIEW_REMOTE_INSTALL_LOCK, x as REVIEW_REMOTE_WRAPPER_MARK } from "./src-Bgvf1sEN.js";
+import "./review-home-paths-zwevIq4I.js";
+import { j as DEV_REVIEW_HOME_ENV } from "./s3-config-DDWWMh5x.js";
+import { c as stopBackgroundServer, o as recordedBackgroundServer } from "./background-server-Cw7CcfaZ.js";
+import { i as whiteboardRemoteHome } from "./remote-extensions-BiNx6NQK.js";
+import { n as remoteLanguageServerGroups, r as stopProcessGroup } from "./remote-language-server-DQgWUNeV.js";
+import { existsSync } from "node:fs";
+import { lstat, mkdir, readFile, readdir, rm, stat } from "node:fs/promises";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+//#region src/remote-uninstall.ts
+const LOCK_STALE_MS = 9e5;
+const REVIEW_STORE = [
+	"review-api.db",
+	"review-api.db-wal",
+	"review-api.db-shm",
+	"review-api.db.workspaces",
+	"review-api.db.workspaces-wal",
+	"review-api.db.workspaces-shm"
+];
+async function remoteUninstall(input) {
+	const refuse = (reason) => ({
+		event: "remote.uninstall",
+		ok: false,
+		reason
+	});
+	if (!path.isAbsolute(input.home)) return refuse(`HOME is ${input.home ? JSON.stringify(input.home) : "not set"}; Whiteboard removes nothing without an absolute home.`);
+	if (!path.isAbsolute(input.stateDir)) return refuse(`The review home ${JSON.stringify(input.stateDir)} is not an absolute path.`);
+	const override = input.env[DEV_REVIEW_HOME_ENV]?.trim();
+	if (override && (/[\x00-\x1f\x7f-\x9f]/.test(override) || override.includes("//") || path.resolve(override) !== (override.replace(/\/$/, "") || "/"))) return refuse(`DEV_REVIEW_HOME is ${JSON.stringify(override)}; Whiteboard removes nothing under a review home that is not an absolute, normalised path.`);
+	const install = whiteboardRemoteHome(input.env);
+	const wrapper = path.join(input.home, ".local", "bin", "whiteboard");
+	const lock = path.join(install, REVIEW_REMOTE_INSTALL_LOCK);
+	const busy = async () => refuse(`Desktop on ${await readText(path.join(lock, "owner")) || "another computer"} is installing Whiteboard here. Try again when it is done.`);
+	if (existsSync(lock)) {
+		if (!await stale(lock)) return busy();
+		await rm(lock, {
+			recursive: true,
+			force: true
+		});
+	}
+	const held = existsSync(install);
+	if (held && !await mkdir(lock).then(() => true, () => false)) return busy();
+	try {
+		return await removeInstall(input, install, wrapper, refuse);
+	} finally {
+		if (held) await rm(lock, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+async function removeInstall(input, install, wrapper, refuse) {
+	const server = await recordedBackgroundServer(input.stateDir);
+	const recorded = server && {
+		...server.discovery,
+		version: server.health.version ?? null
+	};
+	const stoppable = recorded && recorded.startedBy !== "user" ? recorded.serverPid : void 0;
+	const groups = await remoteLanguageServerGroups(input.env);
+	const running = await processesFrom(`${install}/`);
+	if (running === void 0) return refuse(`Cannot list this host's processes to check that none runs from ${install}.`);
+	const others = running.filter(({ pid, pgid }) => pid !== stoppable && !groups.includes(pgid)).map(({ pid }) => pid);
+	if (others.length) return refuse(`${others.map((pid) => pid === recorded?.serverPid ? `A Whiteboard server you started (process ${pid})` : `Process ${pid}`).join(", ")} ${others.length > 1 ? "run" : "runs"} from ${install}. Stop ${others.length > 1 ? "them" : "it"}, then run whiteboard remote uninstall again.`);
+	if (recorded?.startedBy === "user" && input.deleteReviews) return refuse(`A Whiteboard server you started (process ${recorded.serverPid}) uses the reviews in ${input.stateDir}. Stop it, then run whiteboard remote uninstall again.`);
+	await Promise.all(groups.map(stopProcessGroup));
+	let stoppedServer;
+	if (recorded && stoppable !== void 0) {
+		try {
+			await stopBackgroundServer({ serverPid: stoppable });
+		} catch (error) {
+			return refuse(error instanceof Error ? error.message : String(error));
+		}
+		stoppedServer = {
+			pid: stoppable,
+			version: recorded.version
+		};
+	}
+	const left = await processesFrom(`${install}/`);
+	if (left?.length !== 0) return refuse(`${left ? `Process ${left.map(({ pid }) => pid).join(", ")}` : "A process"} still runs from ${install}. Stop it, then run whiteboard remote uninstall again.`);
+	const removed = [];
+	if (existsSync(install)) {
+		await rm(install, {
+			recursive: true,
+			force: true
+		});
+		removed.push(install);
+	}
+	if (await desktopWrote(wrapper)) {
+		await rm(wrapper, { force: true });
+		removed.push(wrapper);
+	}
+	if (input.deleteReviews) for (const name of REVIEW_STORE) {
+		const file = path.join(input.stateDir, name);
+		if (existsSync(file)) {
+			await rm(file, { force: true });
+			removed.push(file);
+		}
+	}
+	const result = {
+		event: "remote.uninstall",
+		ok: true,
+		removed,
+		keptReviews: !input.deleteReviews
+	};
+	if (stoppedServer) result.stoppedServer = stoppedServer;
+	return result;
+}
+async function stale(lock) {
+	const started = await readText(path.join(lock, "started"));
+	if (started !== "") return /^\d+$/.test(started) && Date.now() - Number(started) * 1e3 >= LOCK_STALE_MS;
+	if (existsSync(path.join(lock, "started"))) return false;
+	const since = (await stat(lock).catch(() => void 0))?.mtimeMs;
+	return since !== void 0 && Date.now() - since >= LOCK_STALE_MS;
+}
+const readText = (file) => readFile(file, "utf8").then((text) => text.trim(), () => "");
+async function processesFrom(prefix) {
+	let lines;
+	try {
+		const pids = (await readdir("/proc")).filter((name) => /^\d+$/.test(name));
+		lines = await Promise.all(pids.map(async (pid) => {
+			const [args = "", stat = ""] = await Promise.all([`/proc/${pid}/cmdline`, `/proc/${pid}/stat`].map((file) => readFile(file, "utf8").catch(() => "")));
+			const pgid = Number(stat.slice(stat.lastIndexOf(")") + 2).split(" ")[2]);
+			return {
+				pid: Number(pid),
+				pgid,
+				args: args.replaceAll("\0", " ")
+			};
+		}));
+	} catch {
+		try {
+			const { stdout } = await promisify(execFile)("ps", ["-eo", "pid=,pgid=,args="], { maxBuffer: 16 << 20 });
+			lines = stdout.split("\n").map((line) => {
+				const [, pid = "", pgid = "", args = ""] = /^\s*(\d+)\s+(\d+)\s(.*)$/.exec(line) ?? [];
+				return {
+					pid: Number(pid),
+					pgid: Number(pgid),
+					args
+				};
+			});
+		} catch {
+			return;
+		}
+	}
+	return lines.filter(({ pid, args }) => pid && pid !== process.pid && args.includes(prefix));
+}
+async function desktopWrote(file) {
+	if (!(await lstat(file).catch(() => void 0))?.isFile()) return false;
+	return (await readFile(file, "utf8")).split("\n").includes(REVIEW_REMOTE_WRAPPER_MARK);
+}
+//#endregion
+export { remoteUninstall };

package/dist/{request-origin-DA4K1qWY.js → request-origin-DaRIV3cB.js}

@@ -1,5 +1,5 @@
 import { a as jsonNumber, c as jsonString, i as jsonBoolean, n as isJsonObject } from "./src-X9phtB2j.js";
-import { f as REVIEW_DIFF_LAYOUTS, p as REVIEW_THEME_CHOICES } from "./src-WCbabvdS.js";
+import { S as REVIEW_THEME_CHOICES, h as REVIEW_DIFF_LAYOUT_SCOPES, m as REVIEW_DIFF_LAYOUTS } from "./src-Bgvf1sEN.js";
 import { z } from "zod";
 //#region src/telemetry-clean-text.ts
 const USER_DATA_REGEXES = [
@@ -442,7 +442,10 @@ const UI_TELEMETRY_EVENTS = {
 	},
 	diff_layout_changed: {
 		event: "review_diff_layout_changed",
-		properties: { layout: REVIEW_DIFF_LAYOUTS }
+		properties: {
+			layout: REVIEW_DIFF_LAYOUTS,
+			scope: REVIEW_DIFF_LAYOUT_SCOPES
+		}
 	},
 	review_dismissed: {
 		event: "review_review_dismissed",

package/dist/review-app-launcher-D7I4DGoH.js

@@ -0,0 +1,222 @@
+import { o as parseReviewVerbResponse } from "./src-Bgvf1sEN.js";
+import { b as selectReviewInstance, m as healthyReviewInstance, v as reviewInstanceStartHint, y as reviewInstanceUnavailable } from "./server-discovery-CifQ3yQS.js";
+import { closeSync, existsSync, fstatSync, mkdtempSync, openSync, readSync } from "node:fs";
+import path from "node:path";
+import { homedir, tmpdir } from "node:os";
+import { execFileSync, spawn } from "node:child_process";
+//#region src/review-app-launcher.ts
+const RELEASE_APPS = {
+	stable: {
+		bundleId: "dev.fast.review",
+		macApp: "Whiteboard.app",
+		linuxLauncher: "/usr/bin/review-desktop"
+	},
+	preview: {
+		bundleId: "dev.fast.review.preview",
+		macApp: "Whiteboard Preview.app",
+		linuxLauncher: "/usr/bin/review-preview-desktop"
+	}
+};
+/** "1" on launches without --focus; Desktop opens inactive. */
+const REVIEW_DESKTOP_BACKGROUND_ENV = "DEV_FAST_REVIEW_DESKTOP_BACKGROUND";
+const DEFAULT_LAUNCH_TIMEOUT_MS = 9e4;
+const POLL_INTERVAL_MS = 250;
+const EARLY_EXIT_GRACE_MS = 5e3;
+async function runReviewAppLaunch(input = {}, overrides = {}) {
+	const fetch = overrides.fetch ?? globalThis.fetch;
+	const runtime = {
+		selectInstance: () => selectReviewInstance({ fetch }),
+		fetch,
+		focusDesktop: (discovery) => focusReviewDesktop(discovery, fetch),
+		launchDesktop: launchDesktopApplication,
+		now: Date.now,
+		wait: (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)),
+		...overrides
+	};
+	const selection = await runtime.selectInstance();
+	const current = healthyReviewInstance(selection);
+	if (current) {
+		if (input.focus) await runtime.focusDesktop(current);
+		return launchEvent("running", current.instanceId);
+	}
+	const running = selection.instances.filter((instance) => instance.healthy);
+	if (selection.key !== "stable" && selection.key !== "preview") throw new Error(`${reviewInstanceStartHint(selection)}; \`whiteboard app launch\` starts only installed apps.`);
+	if (selection.source === "fallback" && running.length > 1) throw reviewInstanceUnavailable(selection);
+	const launch = {
+		focus: input.focus,
+		noSandbox: input.noSandbox
+	};
+	if (selection.source !== "fallback") launch.instance = {
+		key: selection.key,
+		appPath: selection.instance?.discovery.appPath
+	};
+	const attempt = runtime.launchDesktop(launch);
+	let completion = observedCompletion(attempt);
+	completion.catch(() => void 0);
+	const deadline = runtime.now() + (input.timeoutMs ?? DEFAULT_LAUNCH_TIMEOUT_MS);
+	let unexpectedSuccessfulExitAt;
+	while (runtime.now() < deadline) {
+		const ready = healthyReviewInstance(await runtime.selectInstance());
+		if (ready) return launchEvent("launched", ready.instanceId);
+		if (unexpectedSuccessfulExitAt !== void 0 && runtime.now() - unexpectedSuccessfulExitAt >= EARLY_EXIT_GRACE_MS) throw launchFailure(attempt, /* @__PURE__ */ new Error("the launch process exited before Desktop became ready"));
+		const remaining = Math.max(0, deadline - runtime.now());
+		const outcome = completion ? await Promise.race([completion.then((result) => ({ completion: result })), runtime.wait(Math.min(POLL_INTERVAL_MS, remaining)).then(() => ({ completion: null }))]) : await runtime.wait(Math.min(POLL_INTERVAL_MS, remaining)).then(() => ({ completion: null }));
+		if (outcome.completion) {
+			assertSuccessfulLaunchCompletion(attempt, outcome.completion);
+			unexpectedSuccessfulExitAt = runtime.now();
+			completion = void 0;
+		}
+	}
+	if (unexpectedSuccessfulExitAt !== void 0) throw launchFailure(attempt, /* @__PURE__ */ new Error("the launch process exited before Desktop became ready"));
+	throw new Error(`Whiteboard Desktop did not become ready within ${Math.ceil((input.timeoutMs ?? DEFAULT_LAUNCH_TIMEOUT_MS) / 1e3)} seconds after ${attempt.method}. Open Whiteboard Desktop once, then run \`whiteboard app launch\` again.${launchDiagnostics(attempt.logPath)}`);
+}
+async function focusReviewDesktop(discovery, fetch) {
+	const response = await fetch(`${discovery.url}/app/focus`, {
+		method: "POST",
+		headers: { "x-review-token": discovery.token },
+		signal: AbortSignal.timeout(5e3)
+	});
+	const result = parseReviewVerbResponse(await response.json());
+	if (!response.ok || !result.ok) throw new Error(result.ok ? `Whiteboard Desktop focus returned ${response.status}.` : result.error);
+}
+function desktopApplicationInstalled(input = {}) {
+	const env = input.env ?? process.env;
+	const platform = input.platform ?? process.platform;
+	const exists = input.exists ?? existsSync;
+	const apps = Object.values(RELEASE_APPS);
+	if (platform !== "linux" && platform !== "darwin" || (input.electron ?? Boolean(process.versions.electron)) || env.DEV_FAST_REVIEW_DESKTOP_COMMAND?.trim()) return true;
+	if (platform === "linux") return apps.some(({ linuxLauncher }) => exists(linuxLauncher));
+	return apps.some(({ macApp }) => ["/Applications", path.join(homedir(), "Applications")].some((dir) => exists(path.join(dir, macApp)))) || apps.some(({ bundleId }) => (input.spotlight ?? spotlightFinds)(bundleId));
+}
+function spotlightFinds(bundleId) {
+	try {
+		return execFileSync("/usr/bin/mdfind", [`kMDItemCFBundleIdentifier == '${bundleId}'`], {
+			encoding: "utf8",
+			timeout: 2e3
+		}).trim() !== "";
+	} catch {
+		return false;
+	}
+}
+function launchDesktopApplication(input = {}) {
+	const platform = input.platform ?? process.platform;
+	if (platform !== "darwin" && platform !== "linux") return {
+		method: `the ${platform} application launcher`,
+		completion: Promise.reject(/* @__PURE__ */ new Error("automatic launch is available only on macOS and Linux"))
+	};
+	if (input.noSandbox && platform !== "linux") return {
+		method: `the ${platform} application launcher`,
+		completion: Promise.reject(/* @__PURE__ */ new Error("--no-sandbox is only supported for Linux Desktop launches."))
+	};
+	const electron = input.electron ?? Boolean(process.versions.electron);
+	const env = { ...input.env ?? process.env };
+	const execPath = input.execPath ?? process.execPath;
+	const focus = input.focus === true;
+	if (focus) delete env[REVIEW_DESKTOP_BACKGROUND_ENV];
+	else env[REVIEW_DESKTOP_BACKGROUND_ENV] = "1";
+	delete env.ELECTRON_RUN_AS_NODE;
+	delete env.DEV_FAST_REVIEW_CHECKOUT;
+	const release = RELEASE_APPS[input.instance?.key ?? "stable"];
+	const stateRoot = env.DEV_FAST_REVIEW_DESKTOP_STATE_ROOT?.trim();
+	const profileArgs = stateRoot ? [`--user-data-dir=${path.resolve(stateRoot, "user-data")}`, `--extensions-dir=${path.resolve(stateRoot, "extensions")}`] : [];
+	let command = "/usr/bin/open";
+	let method;
+	let args;
+	if (platform === "linux") {
+		delete env.VSCODE_DEV;
+		delete env.VSCODE_CLI;
+		command = (input.instance ? "" : env.DEV_FAST_REVIEW_DESKTOP_COMMAND?.trim()) || release.linuxLauncher;
+		method = `the installed Linux launcher at "${command}"`;
+		if (electron && !env.DEV_FAST_REVIEW_DESKTOP_COMMAND?.trim()) {
+			command = execPath;
+			method = `the Desktop-managed bundle at "${command}"`;
+		}
+		args = profileArgs;
+		if (input.noSandbox) args.push("--no-sandbox");
+	} else {
+		const appPath = input.instance ? input.instance.appPath : electron ? execPath.match(/^(.*?\.app)\/Contents\/MacOS\//)?.[1] : void 0;
+		const target = appPath?.endsWith(".app") ? ["-a", appPath] : ["-b", release.bundleId];
+		method = appPath?.endsWith(".app") ? `the macOS application at "${appPath}"` : `the macOS bundle identifier "${release.bundleId}"`;
+		args = [
+			"-n",
+			"-W",
+			...focus ? [] : ["-g"],
+			...target
+		];
+		for (const [key, value] of Object.entries(env)) if (value !== void 0 && /^DEV_(REVIEW|FAST)_/.test(key)) args.push("--env", `${key}=${value}`);
+		if (profileArgs.length > 0) args.push("--args", ...profileArgs);
+	}
+	const { promise: completion, resolve, reject } = Promise.withResolvers();
+	let logPath;
+	let logFd;
+	try {
+		if (platform === "linux") {
+			logPath = path.join(mkdtempSync(path.join(tmpdir(), "whiteboard-launch-")), "stderr.log");
+			logFd = openSync(logPath, "wx", 384);
+		}
+		const child = (input.spawn ?? spawn)(command, args, {
+			detached: true,
+			env,
+			stdio: logFd === void 0 ? "ignore" : [
+				"ignore",
+				"ignore",
+				logFd
+			]
+		});
+		child.once("error", (error) => reject(error));
+		child.once("exit", (code, signal) => {
+			resolve({
+				code,
+				signal
+			});
+		});
+		child.unref();
+	} catch (error) {
+		reject(error instanceof Error ? error : new Error(String(error)));
+	} finally {
+		if (logFd !== void 0) closeSync(logFd);
+	}
+	return {
+		method,
+		logPath,
+		completion
+	};
+}
+function launchEvent(state, instanceId) {
+	return {
+		event: "app",
+		action: "launch",
+		state,
+		instanceId
+	};
+}
+function launchFailure(attempt, error) {
+	return /* @__PURE__ */ new Error(`Could not launch Whiteboard with ${attempt.method}: ${error.message}. Open Whiteboard once, then run \`whiteboard app launch\` again. A sandboxed agent must run it outside the sandbox.${launchDiagnostics(attempt.logPath)}`);
+}
+function assertSuccessfulLaunchCompletion(attempt, completion) {
+	if (completion.code === 0 && !completion.signal) return;
+	throw launchFailure(attempt, /* @__PURE__ */ new Error(completion.signal ? `the launch process exited on ${completion.signal}` : `the launch process exited with code ${completion.code ?? "unknown"}`));
+}
+function observedCompletion(attempt) {
+	return attempt.completion.catch((error) => {
+		throw launchFailure(attempt, error instanceof Error ? error : new Error(String(error)));
+	});
+}
+function launchDiagnostics(logPath) {
+	if (!logPath) return "";
+	let tail = "";
+	try {
+		const fd = openSync(logPath, "r");
+		try {
+			const size = fstatSync(fd).size;
+			const buffer = Buffer.alloc(Math.min(size, 16384));
+			const read = readSync(fd, buffer, 0, buffer.length, size - buffer.length);
+			tail = buffer.subarray(0, read).toString("utf8").trim().split("\n").slice(-20).join("\n");
+		} finally {
+			closeSync(fd);
+		}
+	} catch {}
+	return `\nDesktop log: ${logPath}${tail ? `\n${tail}` : ""}`;
+}
+//#endregion
+export { focusReviewDesktop as n, runReviewAppLaunch as r, desktopApplicationInstalled as t };

package/dist/{review-home-paths-Y9mYWkCI.js → review-home-paths-zwevIq4I.js}

@@ -1,7 +1,7 @@
-import { d as gitAt, u as git, v as resolveRepoContext } from "./src-DiHP11l3.js";
+import { d as git, f as gitAt, y as resolveRepoContext } from "./src-BMPuxWv4.js";
 import { a as jsonNumber, c as jsonString, i as jsonBoolean, m as isStringValue, n as isJsonObject, o as jsonObject, r as jsonArray, t as isJsonArray, u as parseJsonText } from "./src-X9phtB2j.js";
 import { a as TRACE_STORE_CLIENT_ID, b as commitShaSchema, c as deleteStoreResponseSchema, d as listUploadsResponseSchema, f as storeErrorCodeSchema, g as uploadManifestMismatch, h as traceObjectNameSchema, i as storeRoutes, l as listSessionsResponseSchema, m as storeResponseSchema, n as DEVICE_TOKEN_PATH, o as beginUploadResponseSchema, p as storeErrorEnvelopeSchema, r as SESSION_PATH, s as completeUploadResponseSchema, t as DEVICE_CODE_PATH, u as listUploadsQuerySchema, x as sessionIdSchema } from "./src-CGP5ytbV.js";
-import { A as devReviewHome, E as writeTraceConfigFile, M as writeFileAtomic, N as writeFileAtomicAsync, P as writePrivateJsonAtomic, S as readTraceConfigFile, _ as emptyTraceConfig, b as hostedCaptureEnabled, c as resolveS3Setup, d as traceEnvPath, f as traceEnvValue$1, g as currentStore, h as TraceConfigurationError, i as isS3MockMode, j as normalizeStoreOrigin, l as s3CacheIdentity, m as DEFAULT_HOSTED_ORIGIN, n as clearTraceEnvCache$1, p as traceSettingsPath, u as s3MockRoot, v as enabledOriginsOf, w as s3Store, x as hostedOrigin, y as hasHostedStore } from "./s3-config-CAxhO9u_.js";
+import { E as writeTraceConfigFile, F as writeFileAtomicAsync, I as writePrivateJsonAtomic, M as devReviewHome, N as normalizeStoreOrigin, P as writeFileAtomic, S as readTraceConfigFile, _ as emptyTraceConfig, b as hostedCaptureEnabled, c as resolveS3Setup, d as traceEnvPath, f as traceEnvValue$1, g as currentStore, h as TraceConfigurationError, i as isS3MockMode, l as s3CacheIdentity, m as DEFAULT_HOSTED_ORIGIN, n as clearTraceEnvCache$1, p as traceSettingsPath, u as s3MockRoot, v as enabledOriginsOf, w as s3Store, x as hostedOrigin, y as hasHostedStore } from "./s3-config-DDWWMh5x.js";
 import { t as errorMessage } from "./error-message-OtiDonty.js";
 import crypto, { createHash, randomBytes } from "node:crypto";
 import { z } from "zod";
@@ -2537,7 +2537,7 @@ function isTraceStorageConfigured(scope = {}) {
 }
 /** Loads the direct-store implementation on demand, without opening a store. */
 async function loadS3TraceStorage() {
-	return (await import("./s3-SzLpeCG6.js")).S3TraceStorage;
+	return (await import("./s3-77-qkEhs.js")).S3TraceStorage;
 }
 //#endregion
 //#region ../trace-core/src/trace-upload-status.ts
@@ -4684,7 +4684,7 @@ async function describeTraceSession(ref, storage) {
 		commits: ref.commits
 	};
 }
-/** Loads the offline tutorial or a store-compatible normalized trace, preserving freshness and offline fallback status; store refusals propagate. */
+/** Loads a store-compatible normalized trace, preserving freshness and offline fallback status; store refusals propagate. */
 async function loadReviewAgentTrace(input) {
 	const { sessionId, trace } = input;
 	if (!sessionIdSchema.safeParse(sessionId).success) return null;
@@ -5263,7 +5263,7 @@ async function configureTraceMachine(input) {
 	if (input.verify !== false) {
 		if (env.TRACE_R2_MODE === "mock") verifiedAt = (/* @__PURE__ */ new Date()).toISOString();
 		else {
-			const { S3TraceStorage } = await import("./s3-SzLpeCG6.js");
+			const { S3TraceStorage } = await import("./s3-77-qkEhs.js");
 			const readiness = await S3TraceStorage.fromCredentials({
 				endpoint: credentials.endpoint,
 				bucket: credentials.bucket,
@@ -5734,7 +5734,7 @@ async function runTraceStatus(input) {
 		input.stderr.write("Upload status filters require hosted storage.\n");
 		return 1;
 	}
-	const [{ S3TraceStorage }, { describeS3Setup, noTraceConfigurationMessage }] = await Promise.all([import("./s3-SzLpeCG6.js"), import("./s3-config-BgxkSoOy.js")]);
+	const [{ S3TraceStorage }, { describeS3Setup, noTraceConfigurationMessage }] = await Promise.all([import("./s3-77-qkEhs.js"), import("./s3-config-0xuCh-F_.js")]);
 	const setup = describeS3Setup(input.scope.env);
 	input.stdout.write(`Checking trace configuration (${setup.envPath})…\n`);
 	for (const failure of await listTraceSyncFailures(input.scope.devHome)) input.stdout.write(describeTraceSyncFailure(failure));
@@ -6401,4 +6401,4 @@ function reviewDesktopStateDir(env = process.env) {
 	return path.join(reviewDesktopRoot(env), "state");
 }
 //#endregion
-export { resolveTraceCommand as $, runTraceDeny as A, TraceStorageDeniedError as B, disableTraceMachine as C, listReviewTraceSessions as D, traceMachineStatus as E, describeSelection as F, listTraceRepositoryRoots as G, resolveTraceRepositoryTarget as H, isTraceStorageConfigured as I, HOSTED_CAPTURE_SCOPE_DESCRIPTION as J, traceRepositoryStatus as K, loadS3TraceStorage as L, runTraceSessions as M, runTraceStoreDelete as N, loadReviewAgentTrace as O, runTraceStoreInfo as P, removeAgentTraceHook as Q, resolveTraceStorage as R, configureTraceMachine as S, traceMachineEnabled as T, disableAllTraceRepositories as U, requireTraceConsent as V, enableTraceRepository as W, describeTraceHookOwners as X, AGENT_TRACE_HOOK_AGENTS as Y, installHarnessHooks as Z, runTraceRepair as _, reviewInstancesDir as a, openUrlInBrowser as at, runTraceGitHook as b, registerTraceCommands as c, runStoreLogout as ct, runTraceList as d, StoreClient as dt, shellQuote as et, runTracePull as f, withStoreAuthorization as ft, runTraceInstallMachine as g, jsonRequestedInArgv as gt, runTraceEnable as h, humanStream as ht, reviewInstanceDiscoveryPath as i, clearStoreAuth as it, runTraceOnboard as j, runTraceAllow as k, resolveTraceReadStorage as l, runStoreWhoami as lt, runTraceDisable as m, failWithJsonError as mt, reviewDesktopStateDir as n, traceScope as nt, reviewLegacyDiscoveryPath as o, readStoreAuth as ot, runTraceShow as p, emitJsonEvent as pt, readTraceUserConfig as q, reviewDevInstanceKey as r, DEFAULT_STORE_ORIGIN as rt, safeStorageSegment as s, runStoreLogin as st, reviewDefaultInstancePath as t, traceHomeDir as tt, runTraceBlame as u, StoreApiError as ut, runTraceStatus as v, readLegacyCaptureSettings as w, runTraceHook as x, runTraceSync as y, selectTraceStorage as z };
+export { removeAgentTraceHook as $, runTraceDeny as A, TraceStorageDeniedError as B, disableTraceMachine as C, listReviewTraceSessions as D, traceMachineStatus as E, describeSelection as F, listTraceRepositoryRoots as G, resolveTraceRepositoryTarget as H, isTraceStorageConfigured as I, HOSTED_CAPTURE_SCOPE_DESCRIPTION as J, traceRepositoryStatus as K, loadS3TraceStorage as L, runTraceSessions as M, runTraceStoreDelete as N, loadReviewAgentTrace as O, runTraceStoreInfo as P, installHarnessHooks as Q, resolveTraceStorage as R, configureTraceMachine as S, traceMachineEnabled as T, disableAllTraceRepositories as U, requireTraceConsent as V, enableTraceRepository as W, agentTraceHomeDirectory as X, AGENT_TRACE_HOOK_AGENTS as Y, describeTraceHookOwners as Z, runTraceRepair as _, jsonRequestedInArgv as _t, reviewInstancesDir as a, clearStoreAuth as at, runTraceGitHook as b, registerTraceCommands as c, runStoreLogin as ct, runTraceList as d, StoreApiError as dt, resolveTraceCommand as et, runTracePull as f, StoreClient as ft, runTraceInstallMachine as g, humanStream as gt, runTraceEnable as h, failWithJsonError as ht, reviewInstanceDiscoveryPath as i, DEFAULT_STORE_ORIGIN as it, runTraceOnboard as j, runTraceAllow as k, resolveTraceReadStorage as l, runStoreLogout as lt, runTraceDisable as m, emitJsonEvent as mt, reviewDesktopStateDir as n, traceHomeDir as nt, reviewLegacyDiscoveryPath as o, openUrlInBrowser as ot, runTraceShow as p, withStoreAuthorization as pt, readTraceUserConfig as q, reviewDevInstanceKey as r, traceScope as rt, safeStorageSegment as s, readStoreAuth as st, reviewDefaultInstancePath as t, shellQuote as tt, runTraceBlame as u, runStoreWhoami as ut, runTraceStatus as v, readLegacyCaptureSettings as w, runTraceHook as x, runTraceSync as y, selectTraceStorage as z };

package/dist/{review-telemetry-CmM6tCbj.js → review-telemetry-BqB4CiTD.js}

@@ -1,9 +1,9 @@
 import { c as jsonString, l as jsonValueSchema, o as jsonObject, u as parseJsonText } from "./src-X9phtB2j.js";
-import "./src-WCbabvdS.js";
-import "./review-home-paths-Y9mYWkCI.js";
-import { A as devReviewHome, D as processIsAlive, M as writeFileAtomic, O as withFileLock } from "./s3-config-CAxhO9u_.js";
-import { i as readReviewPackageVersion, t as findReviewPackageRoot } from "./package-paths-B9PDoAl6.js";
-import "./request-origin-DA4K1qWY.js";
+import "./src-Bgvf1sEN.js";
+import "./review-home-paths-zwevIq4I.js";
+import { A as withFileLock, M as devReviewHome, O as processIsAlive, P as writeFileAtomic } from "./s3-config-DDWWMh5x.js";
+import { i as readReviewPackageVersion, t as findReviewPackageRoot } from "./package-paths-BsuI4WUf.js";
+import "./request-origin-DaRIV3cB.js";
 import { createHmac, randomUUID } from "node:crypto";
 import { z } from "zod";
 import { existsSync, readFileSync, rmSync } from "node:fs";

package/dist/{s3-SzLpeCG6.js → s3-77-qkEhs.js}

@@ -1,6 +1,6 @@
 import { a as jsonNumber, c as jsonString, o as jsonObject, r as jsonArray, u as parseJsonText } from "./src-X9phtB2j.js";
 import { S as sessionMetaSchema, b as commitShaSchema, y as byCommitSchema } from "./src-CGP5ytbV.js";
-import { i as isS3MockMode, l as s3CacheIdentity, s as resolveS3Credentials, u as s3MockRoot } from "./s3-config-CAxhO9u_.js";
+import { i as isS3MockMode, l as s3CacheIdentity, s as resolveS3Credentials, u as s3MockRoot } from "./s3-config-DDWWMh5x.js";
 import { t as errorMessage } from "./error-message-OtiDonty.js";
 import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
 import path from "node:path";

package/dist/{s3-config-BgxkSoOy.js → s3-config-0xuCh-F_.js}

@@ -1,2 +1,2 @@
-import { a as noTraceConfigurationMessage, c as resolveS3Setup, d as traceEnvPath, f as traceEnvValue, i as isS3MockMode, l as s3CacheIdentity, n as clearTraceEnvCache, o as readTraceEnvFile, p as traceSettingsPath, r as describeS3Setup, s as resolveS3Credentials, t as S3_DEFAULT_REGION, u as s3MockRoot } from "./s3-config-CAxhO9u_.js";
+import { a as noTraceConfigurationMessage, c as resolveS3Setup, d as traceEnvPath, f as traceEnvValue, i as isS3MockMode, l as s3CacheIdentity, n as clearTraceEnvCache, o as readTraceEnvFile, p as traceSettingsPath, r as describeS3Setup, s as resolveS3Credentials, t as S3_DEFAULT_REGION, u as s3MockRoot } from "./s3-config-DDWWMh5x.js";
 export { S3_DEFAULT_REGION, clearTraceEnvCache, describeS3Setup, isS3MockMode, noTraceConfigurationMessage, readTraceEnvFile, resolveS3Credentials, resolveS3Setup, s3CacheIdentity, s3MockRoot, traceEnvPath, traceEnvValue, traceSettingsPath };

package/dist/{s3-config-CAxhO9u_.js → s3-config-DDWWMh5x.js}

@@ -229,6 +229,10 @@ async function withFileLock(lockPath, options, operation) {
 		});
 	}
 }
+async function liveLockOwner(lockPath) {
+	const owner = await readLockOwner(lockPath);
+	return owner && processIsAlive(owner.pid) && !pidReused(owner.pid, owner.started) ? owner.pid : void 0;
+}
 function processIsAlive(pid) {
 	try {
 		process.kill(pid, 0);
@@ -673,4 +677,4 @@ function normalizeS3Endpoint(endpoint) {
 	}
 }
 //#endregion
-export { devReviewHome as A, s3ProfileSchema as C, processIsAlive as D, writeTraceConfigFile as E, writeFileAtomic as M, writeFileAtomicAsync as N, withFileLock as O, writePrivateJsonAtomic as P, readTraceConfigFile as S, sameS3Profile as T, emptyTraceConfig as _, noTraceConfigurationMessage as a, hostedCaptureEnabled as b, resolveS3Setup as c, traceEnvPath as d, traceEnvValue as f, currentStore as g, TraceConfigurationError as h, isS3MockMode as i, normalizeStoreOrigin as j, DEV_REVIEW_HOME_ENV as k, s3CacheIdentity as l, DEFAULT_HOSTED_ORIGIN as m, clearTraceEnvCache as n, readTraceEnvFile as o, traceSettingsPath as p, describeS3Setup as r, resolveS3Credentials as s, S3_DEFAULT_REGION as t, s3MockRoot as u, enabledOriginsOf as v, s3Store as w, hostedOrigin as x, hasHostedStore as y };
+export { withFileLock as A, s3ProfileSchema as C, liveLockOwner as D, writeTraceConfigFile as E, writeFileAtomicAsync as F, writePrivateJsonAtomic as I, devReviewHome as M, normalizeStoreOrigin as N, processIsAlive as O, writeFileAtomic as P, readTraceConfigFile as S, sameS3Profile as T, emptyTraceConfig as _, noTraceConfigurationMessage as a, hostedCaptureEnabled as b, resolveS3Setup as c, traceEnvPath as d, traceEnvValue as f, currentStore as g, TraceConfigurationError as h, isS3MockMode as i, DEV_REVIEW_HOME_ENV as j, processStartIdentity as k, s3CacheIdentity as l, DEFAULT_HOSTED_ORIGIN as m, clearTraceEnvCache as n, readTraceEnvFile as o, traceSettingsPath as p, describeS3Setup as r, resolveS3Credentials as s, S3_DEFAULT_REGION as t, s3MockRoot as u, enabledOriginsOf as v, s3Store as w, hostedOrigin as x, hasHostedStore as y };