glimmervoid 0.42.3 → 0.43.0

package/dist/chunks/{main-DOZJniDn.js → main-_78bVmTr.js}

@@ -2,13 +2,13 @@ import { i as sanitizeOneLine, n as requireExecutableSpawnHelper, r as firstLine
 import { a as isMissingFileError, i as errorText$1, r as errorMessage, t as errorCode } from "./text-DoirglWV.js";
 import { a as sanitizeWorktreeName, i as safePathSegment, n as equalsIgnoringCaseOnWindows, r as isPathInside, t as caseFoldedPathKey } from "./paths-Bu4eH1Yd.js";
 import { a as packageRoot, n as cliPath, o as relayPath, r as clientDir, s as resolvePackageBin, t as bundled } from "./runtime-paths-BkeftE60.js";
-import { $t as STATES, A as SIGN_URL_ENV, At as TeamReviewStatus, B as LinkedPr, Bt as shortSha, Ct as ReviewThreadId, Dt as TeamReviewCompareFiles, E as SESSION_DOC_BODY_CAP_BYTES, Ft as decisionAsIfApprovalRequired, G as MyPrKeepMergeableRequest, H as MyPrAutoRebase, Ht as NODE_ID_RE, I as SshSignRequest, J as MyPrMergeMethod, L as TASK_TITLE_CONTROL_CHARACTERS, Lt as hasStandingViewerApproval, Mt as TeamReviewThreadResult, Nt as TeamReviewThreadsRepository, O as SESSION_NAME_PATTERN, Ot as TeamReviewResolveResponse, Pt as canApproveAfterComment, Q as MyPrMergeWhenReadyRequest, Qt as RESTARTABLE_STATES, R as TaskTitle, S as ConversationQuestion, St as ReviewResult, Tt as TeamReviewActionRequest, U as MyPrCheckContext, Ut as REPO_SLUG_RE, V as MyPr, Vt as GH_SEGMENT, W as MyPrCheckContextsResponse, Wt as repoParts, Xt as KILLABLE_STATES, Y as MyPrMergeRequest, Yt as BADGE_LABELS, Z as MyPrMergeStateResponse, Zt as MERGEABLE_LIVE_STATES, _ as CONVERSATION_TOOL_RESULT_HOOK_EVENT, _t as QueuedReview, bt as ReviewDraft, dt as EarlierReview, ft as FindingSeverity, g as CONVERSATION_PERMISSION_HOOK_EVENT, gt as PrDetail, h as CONVERSATION_APPROVAL_SUMMARY_MAX_CHARS, ht as PostingPlan, it as MyPrsState, j as SSH_SIGN_BODY_CAP_BYTES, jt as TeamReviewThreadCommentsResponse, k as SESSION_NAME_RULE_TEXT, kt as TeamReviewStateEntry, lt as CommitSha, m as COHERENCE_HOOKS_INACTIVE, mt as GithubReviewState, n as AGENT_URL_ENV, nt as MyPrThreadsResponse, q as MyPrLaneEntry, r as ASK_USER_QUESTION_TOOL_NAME, rt as MyPrsSnapshot, tt as MyPrThreadNode, ut as DECIDING_REVIEW_STATES, w as RefinedTaskTitle, wt as ReviewVerdict, xt as ReviewFinding, yt as ReviewComment, zt as HEX_SHA_RE } from "./session-3eSP3t1i.js";
+import { $t as STATES, A as SIGN_URL_ENV, At as TeamReviewStatus, B as LinkedPr, Bt as shortSha, Ct as ReviewThreadId, Dt as TeamReviewCompareFiles, E as SESSION_DOC_BODY_CAP_BYTES, Ft as decisionAsIfApprovalRequired, G as MyPrKeepMergeableRequest, H as MyPrAutoRebase, Ht as NODE_ID_RE, I as SshSignRequest, J as MyPrMergeMethod, L as TASK_TITLE_CONTROL_CHARACTERS, Lt as hasStandingViewerApproval, Mt as TeamReviewThreadResult, Nt as TeamReviewThreadsRepository, O as SESSION_NAME_PATTERN, Ot as TeamReviewResolveResponse, Pt as canApproveAfterComment, Q as MyPrMergeWhenReadyRequest, Qt as RESTARTABLE_STATES, R as TaskTitle, S as ConversationQuestion, St as ReviewResult, Tt as TeamReviewActionRequest, U as MyPrCheckContext, Ut as REPO_SLUG_RE, V as MyPr, Vt as GH_SEGMENT, W as MyPrCheckContextsResponse, Wt as repoParts, Xt as KILLABLE_STATES, Y as MyPrMergeRequest, Yt as BADGE_LABELS, Z as MyPrMergeStateResponse, Zt as MERGEABLE_LIVE_STATES, _ as CONVERSATION_TOOL_RESULT_HOOK_EVENT, _t as QueuedReview, bt as ReviewDraft, dt as EarlierReview, ft as FindingSeverity, g as CONVERSATION_PERMISSION_HOOK_EVENT, gt as PrDetail, h as CONVERSATION_APPROVAL_SUMMARY_MAX_CHARS, ht as PostingPlan, it as MyPrsState, j as SSH_SIGN_BODY_CAP_BYTES, jt as TeamReviewThreadCommentsResponse, k as SESSION_NAME_RULE_TEXT, kt as TeamReviewStateEntry, lt as CommitSha, m as COHERENCE_HOOKS_INACTIVE, mt as GithubReviewState, n as AGENT_URL_ENV, nt as MyPrThreadsResponse, q as MyPrLaneEntry, r as ASK_USER_QUESTION_TOOL_NAME, rt as MyPrsSnapshot, tt as MyPrThreadNode, ut as DECIDING_REVIEW_STATES, w as RefinedTaskTitle, wt as ReviewVerdict, xt as ReviewFinding, yt as ReviewComment, zt as HEX_SHA_RE } from "./session-BUcx9uJa.js";
 import { n as execFileAsync, o as spawn, r as execFileSync, t as execFile } from "./child-process-safe-D4hyVIXj.js";
-import { At as GithubIssueResponse, C as comparablePrKey, Ct as PLAN_RESULT_HOOK_EVENT, Dt as parseExitPlanModeHookPayload, E as WorkflowsSettings, Et as PlanRevision, F as KEEP_MERGEABLE_TIMEOUT_MINUTES_RANGE, Ft as IssuesStatus, It as issuePullRequestStateFromGithub, Mt as IssueUpdate, Nt as IssuesSearchResponse, O as WorkflowsState, Ot as planTitle, Pt as IssuesState, S as GithubPrsFrame, St as PLAN_HOOK_OUTPUT_MAX_CHARS, T as WorkflowLabelName, Tt as PlanDecision, _ as MinedPrReviewData, _t as CoherenceJournalOutput, b as GithubPrKey, bt as PLAN_BODY_CAP_BYTES, c as BenchmarkActionRequest, d as BenchmarkJudgement, f as BenchmarkRun, ft as UpdateJournal, g as MergedPrListing, gt as TraceRecord, h as CommitComparison, ht as TraceCheckpoint, jt as IssueKey, kt as GithubIssuePullRequestsRepository, l as BenchmarkCase, m as BenchmarkSuite, mt as MAX_RAW_LINE_CHARS, n as ClientMessage, p as BenchmarkStatus, pt as SessionSetup, s as pullRequestKeyFromReference, t as CONTROL_FRAME_MAX_BYTES, tt as USAGE_INTEGER_RANGES, u as BenchmarkId, v as PrCheckoutCaseInput, vt as ChangeMap, w as WorkflowCommentBody, wt as PLAN_TOOL_NAME, x as GithubPrLightSearchNode, xt as PLAN_HOOK_EVENT, y as GithubPrDetailNode, yt as changeMapFactId } from "./control-messages-Dgap3JRR.js";
-import { a as permitsHelpCommand, r as describeSessionLimits } from "./session-routes-B2oSzmQn.js";
-import { a as decideSpawnAllowance, c as describeKeptChildAttention, d as describeUnpushedCloseRefusal, h as projectReviews, i as decideAgentRequest, l as describePushLanding, m as projectMyPrs, n as REFUSAL_REASON, o as deriveChildSessionName, p as parseAgentVerb, s as describeChildEndNote, u as describeRoleRefusal } from "./agent-api-core-DFYLP1bF.js";
+import { At as GithubIssueResponse, C as comparablePrKey, Ct as PLAN_RESULT_HOOK_EVENT, Dt as parseExitPlanModeHookPayload, E as WorkflowsSettings, Et as PlanRevision, F as KEEP_MERGEABLE_TIMEOUT_MINUTES_RANGE, Ft as IssuesStatus, It as issuePullRequestStateFromGithub, Mt as IssueUpdate, Nt as IssuesSearchResponse, O as WorkflowsState, Ot as planTitle, Pt as IssuesState, S as GithubPrsFrame, St as PLAN_HOOK_OUTPUT_MAX_CHARS, T as WorkflowLabelName, Tt as PlanDecision, _ as MinedPrReviewData, _t as CoherenceJournalOutput, b as GithubPrKey, bt as PLAN_BODY_CAP_BYTES, c as BenchmarkActionRequest, d as BenchmarkJudgement, f as BenchmarkRun, ft as UpdateJournal, g as MergedPrListing, gt as TraceRecord, h as CommitComparison, ht as TraceCheckpoint, jt as IssueKey, kt as GithubIssuePullRequestsRepository, l as BenchmarkCase, m as BenchmarkSuite, mt as MAX_RAW_LINE_CHARS, n as ClientMessage, p as BenchmarkStatus, pt as SessionSetup, s as pullRequestKeyFromReference, t as CONTROL_FRAME_MAX_BYTES, tt as USAGE_INTEGER_RANGES, u as BenchmarkId, v as PrCheckoutCaseInput, vt as ChangeMap, w as WorkflowCommentBody, wt as PLAN_TOOL_NAME, x as GithubPrLightSearchNode, xt as PLAN_HOOK_EVENT, y as GithubPrDetailNode, yt as changeMapFactId } from "./control-messages-CD99vE0V.js";
+import { a as permitsHelpCommand, r as describeSessionLimits } from "./session-routes-DdeSkLqC.js";
+import { a as decideSpawnAllowance, c as describeKeptChildAttention, d as describeUnpushedCloseRefusal, h as projectReviews, i as decideAgentRequest, l as describePushLanding, m as projectMyPrs, n as REFUSAL_REASON, o as deriveChildSessionName, p as parseAgentVerb, s as describeChildEndNote, u as describeRoleRefusal } from "./agent-api-core-BeSecYrA.js";
 import { n as glimmervoidHomeDir, t as decideConfigPath } from "./config-path-core-DFt-TemS.js";
-import { i as parseCommandLine, n as warnWhenGitIsTooOld } from "./git-version-DqagvnAZ.js";
+import { i as parseCommandLine, n as warnWhenGitIsTooOld } from "./git-version-ByOV7a_h.js";
 import { n as checkGuardrailsDependencies, t as allowGuardedSpawn } from "./guardrails-deps-BjPzk1rE.js";
 import { t as HOOK_URL_ENV } from "./hook-relay-core-DA_bz2KA.js";
 import { t as HOOK_VIA_GUARDRAILS_PROXY_ENV } from "./guardrails-proxy-core-BI3rdY-m.js";
@@ -21,13 +21,13 @@ import { n as DEFAULT_MAX_MS, r as nextBackoffMs, t as DEFAULT_BASE_MS } from ".
 import { n as unrefTimer, t as DEFAULT_TIMER_FNS } from "./timer-deps-u2DAQLok.js";
 import { n as shellQuote } from "./hook-command-core-qTNK-xMF.js";
 import { C as parseCgroupBytes, S as memoryReserveBytes, T as parseMemAvailableBytes, _ as createSpawnGate, a as jsonStateLoadError, b as cgroupLimitBytes, c as loadedJsonValue, d as writeJsonAtomicSync, f as writeTextAtomic, g as createSerialQueue, h as createMemoryAdmission, i as createJsonStateWriter, m as createKeyedSerialQueue, n as appendJsonLines, o as loadJsonStateFile, p as writeTextAtomicSync, r as createJsonStateStore, s as loadJsonStateFileSync, t as appendJsonLine, u as writeJsonAtomic, v as isQueueAdmissionTimeout, w as parseCgroupV2Path, x as headroomFromReadings, y as cgroupAncestorPaths } from "./json-file-DFCTvPjj.js";
-import { $ as DEFAULT_BRANCH_GC_PREFIXES, B as buildExceptionProperties, F as TELEMETRY_BATCH_URL, G as exceptionFingerprint, H as decideIsDevInstall, I as TELEMETRY_FLAGS_URL, J as resolveProjectToken, K as nodeMajorVersion, L as adapterBucket, P as FIRST_RUN_NOTICE, R as buildAiGenerationEvents, U as decideRemoteTelemetryState, V as classifySessionExit, W as decideTelemetryConsent, Z as stableConfigKey, a as generateProjectId, at as worktreeIntegrationTips, b as validateSettingsBlock, ct as isSameDirectoryPath, d as assetForPlatform, et as matchedPrefix, f as decideRtkInstall, g as verifyDigest, h as isRtkBinaryName, i as ensureProjectIds, it as usablePrefixes, m as installTargetPath, n as DEFAULT_CONFIG, nt as planWorktreeGc, o as glimmervoidHomeDir$1, ot as canonicalizePath, p as findEscapingArchiveMember, q as parsePosthogReleaseId, r as createConfigStore, rt as sessionIdFromBranch, st as comparableDirectoryPath, t as ABORT_CONFIG_SAVE, tt as planBranchGc, v as mergeSettingsBlock, y as settingsBlockSpecFor, z as buildBrowserExceptionProperties } from "./config-store-DOGtTJ1d.js";
-import { T as USAGE_VENDOR_KEYS, _ as PersistedTaskTitle, a as parseDataClientMessage, b as configIssueMessage, c as PendingCrashReport, d as TelemetryState, g as ConfigUpdate, i as parseDataAttachHistory, l as TELEMETRY_EVENT_SCHEMAS, m as BrowserConfig, n as HookEnvelope, o as DashboardTelemetryReport, r as DEEP_HISTORY_SCROLLBACK_LINES, t as HTTP_URL_RE, v as RUNTIME_CONFIG_SCALAR_KEYS, w as USAGE_COST_MODES, y as TASK_TITLE_SOURCE_PRIORITY } from "./contracts-Ds_eevZs.js";
-import { A as dedupeCodexFiles, B as shouldPersistWarehouse, C as shortSha$1, D as codexSessionIdFromPath, E as codexRootCandidates, F as passOutcome, H as claudeCode, I as projectDirCandidates, L as resolveProjectsDirs, M as grokHomes, N as grokRootCandidates, O as continuationDelayMs, P as isUsageFile, R as scopedClaudeRoots, S as parseResolvedSha, T as codexHomes, V as splitLines$1, _ as isCheckFresh, a as describeAgentResolvability, b as parseRegistryDeprecation, c as isKnownAgentId, d as resolveAdapter, f as setCustomAgents, g as decideUpdateStatus, h as decideInstallFlavor, i as customAgentFingerprint, j as expandTilde, k as decideFileRead, l as listAgentIds, m as readHostCodexVersion, n as cachedAgentResolvability, o as getAdapter, p as codex, r as commandFor, s as hookProfileOf, t as DEFAULT_AGENT_ID, u as resetCommandCache, v as normalizeSha, w as codexFallbackRoots, x as parseRegistryLatest, y as normalizeUpdateChannel, z as shouldEvaluateDespiteIoFailures } from "./adapters-Bga1N6Ie.js";
+import { $ as DEFAULT_BRANCH_GC_PREFIXES, B as buildExceptionProperties, F as TELEMETRY_BATCH_URL, G as exceptionFingerprint, H as decideIsDevInstall, I as TELEMETRY_FLAGS_URL, J as resolveProjectToken, K as nodeMajorVersion, L as adapterBucket, P as FIRST_RUN_NOTICE, R as buildAiGenerationEvents, U as decideRemoteTelemetryState, V as classifySessionExit, W as decideTelemetryConsent, Z as stableConfigKey, a as generateProjectId, at as worktreeIntegrationTips, b as validateSettingsBlock, ct as isSameDirectoryPath, d as assetForPlatform, et as matchedPrefix, f as decideRtkInstall, g as verifyDigest, h as isRtkBinaryName, i as ensureProjectIds, it as usablePrefixes, m as installTargetPath, n as DEFAULT_CONFIG, nt as planWorktreeGc, o as glimmervoidHomeDir$1, ot as canonicalizePath, p as findEscapingArchiveMember, q as parsePosthogReleaseId, r as createConfigStore, rt as sessionIdFromBranch, st as comparableDirectoryPath, t as ABORT_CONFIG_SAVE, tt as planBranchGc, v as mergeSettingsBlock, y as settingsBlockSpecFor, z as buildBrowserExceptionProperties } from "./config-store-CBjnq-OI.js";
+import { T as USAGE_VENDOR_KEYS, _ as PersistedTaskTitle, a as parseDataClientMessage, b as configIssueMessage, c as PendingCrashReport, d as TelemetryState, g as ConfigUpdate, i as parseDataAttachHistory, l as TELEMETRY_EVENT_SCHEMAS, m as BrowserConfig, n as HookEnvelope, o as DashboardTelemetryReport, r as DEEP_HISTORY_SCROLLBACK_LINES, t as HTTP_URL_RE, v as RUNTIME_CONFIG_SCALAR_KEYS, w as USAGE_COST_MODES, y as TASK_TITLE_SOURCE_PRIORITY } from "./contracts-BJGgl8et.js";
+import { A as dedupeCodexFiles, B as shouldPersistWarehouse, C as shortSha$1, D as codexSessionIdFromPath, E as codexRootCandidates, F as passOutcome, H as claudeCode, I as projectDirCandidates, L as resolveProjectsDirs, M as grokHomes, N as grokRootCandidates, O as continuationDelayMs, P as isUsageFile, R as scopedClaudeRoots, S as parseResolvedSha, T as codexHomes, V as splitLines$1, _ as isCheckFresh, a as describeAgentResolvability, b as parseRegistryDeprecation, c as isKnownAgentId, d as resolveAdapter, f as setCustomAgents, g as decideUpdateStatus, h as decideInstallFlavor, i as customAgentFingerprint, j as expandTilde, k as decideFileRead, l as listAgentIds, m as readHostCodexVersion, n as cachedAgentResolvability, o as getAdapter, p as codex, r as commandFor, s as hookProfileOf, t as DEFAULT_AGENT_ID, u as resetCommandCache, v as normalizeSha, w as codexFallbackRoots, x as parseRegistryLatest, y as normalizeUpdateChannel, z as shouldEvaluateDespiteIoFailures } from "./adapters-jRUJYLhH.js";
 import { t as HOOK_TOOLS } from "./hook-tools-Dl7-r2Eb.js";
 import { a as formatSshPublicKey, c as orderAgentSockets, i as commitSigningShimText, l as parseSshPublicKey, n as NO_AGENT_HOLDS_KEY, o as isForwardedAgentDirName, r as agentListsKey, s as isSignableGitObject, t as COMMIT_SIGNING_SHIM_NAME } from "./ssh-signing-core-CRhVVWNW.js";
-import { a as configSiblingPath, c as defaultPairingsPath, d as decideDeviceAuth, f as deviceNameFromUserAgent, l as defaultSeenPath, n as normalizeRemoteConfig, o as createPairingsStore, p as hashSecret, r as validateRemoteConfig, s as createSeenStore, t as decideBindHost, u as DEFAULT_DEVICE_MAX_AGE_MS } from "./remote-config-DeWURqqr.js";
-import { n as configFileViewOf, u as readSettingsForAgent } from "./settings-readout-core-C2mOk9Yz.js";
+import { a as configSiblingPath, c as defaultPairingsPath, d as decideDeviceAuth, f as deviceNameFromUserAgent, l as defaultSeenPath, n as normalizeRemoteConfig, o as createPairingsStore, p as hashSecret, r as validateRemoteConfig, s as createSeenStore, t as decideBindHost, u as DEFAULT_DEVICE_MAX_AGE_MS } from "./remote-config-BdCTswa1.js";
+import { n as configFileViewOf, u as readSettingsForAgent } from "./settings-readout-core-CBqSjZiW.js";
 import { _ as escapeMarkup, g as createLaneLog, n as createVisionsSetup } from "./visions-setup-DB2P8JUL.js";
 import { t as getRtkPath } from "./rtk-resolver-BDHi6RMv.js";
 import { createRequire } from "node:module";
@@ -39,7 +39,7 @@ import crypto, { createHash, randomBytes, randomInt, randomUUID } from "node:cry
 import WebSocket$1, { WebSocket, WebSocketServer } from "ws";
 import http from "node:http";
 import net, { isIPv6 } from "node:net";
-import fsp, { access, chmod, copyFile, lstat, mkdir, mkdtemp, open, readFile, readdir, readlink, realpath, rename, rm, stat, symlink, writeFile } from "node:fs/promises";
+import fs$1, { access, chmod, copyFile, lstat, mkdir, mkdtemp, open, readFile, readdir, readlink, realpath, rename, rm, stat, symlink, writeFile } from "node:fs/promises";
 import { pipeline } from "node:stream";
 import express from "express";
 import { EventEmitter } from "node:events";
@@ -49,6 +49,168 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import https from "node:https";
 import { StringDecoder } from "node:string_decoder";
 import { monitorEventLoopDelay } from "node:perf_hooks";
+//#region shared/contracts/owned-paths.ts
+var OwnedPathOwner = z.string().regex(/^(session|lane):[A-Za-z0-9._:#-]+$/);
+var OwnedPathEntry = z.object({
+	path: z.string().min(1),
+	owner: OwnedPathOwner,
+	kind: z.enum(["git-worktree", "folder"]),
+	projectPath: z.string().min(1).nullable(),
+	branch: z.string().min(1).nullable()
+}).strict();
+var OwnedPathsLedger = z.object({
+	version: z.literal(1),
+	entries: z.array(OwnedPathEntry)
+}).strict();
+//#endregion
+//#region server/core/owned-paths-core.ts
+var SESSION_OWNER_PREFIX = "session:";
+var RESTART_SURVIVING_LANE_OWNERS = /* @__PURE__ */ new Set(["lane:update-apply", "lane:team-review"]);
+function isOwnerGone(owner, configuredSessionIds) {
+	if (!owner.startsWith(SESSION_OWNER_PREFIX)) return !RESTART_SURVIVING_LANE_OWNERS.has(owner);
+	return !configuredSessionIds.has(owner.slice(8));
+}
+function orphanedOwnedPaths(entries, configuredSessionIds) {
+	const orphans = entries.filter((entry) => isOwnerGone(entry.owner, configuredSessionIds));
+	return [...orphans.filter((entry) => entry.kind === "git-worktree"), ...orphans.filter((entry) => entry.kind === "folder")];
+}
+function holdsKeptPath(folderPath, keptPaths) {
+	return keptPaths.some((keptPath) => {
+		const relativePath = path.relative(folderPath, keptPath);
+		return relativePath === "" || !relativePath.startsWith("..") && !path.isAbsolute(relativePath);
+	});
+}
+//#endregion
+//#region server/owned-paths-ledger.ts
+function ownedPathsLedgerPath(glimmervoidHome = glimmervoidHomeDir$1()) {
+	return path.join(glimmervoidHome, "owned-paths.json");
+}
+function ledgerKey(ownedPath) {
+	return caseFoldedPathKey(path.resolve(ownedPath));
+}
+async function canonicalOwnedPath(ownedPath) {
+	const resolvedPath = path.resolve(ownedPath);
+	const missingSegments = [];
+	let existingAncestor = resolvedPath;
+	while (true) {
+		const realAncestor = await fs$1.realpath(existingAncestor).catch(() => null);
+		if (realAncestor !== null) return path.join(realAncestor, ...missingSegments);
+		const parent = path.dirname(existingAncestor);
+		if (parent === existingAncestor) return resolvedPath;
+		missingSegments.unshift(path.basename(existingAncestor));
+		existingAncestor = parent;
+	}
+}
+function createOwnedPathsLedger({ filePath, log = console }) {
+	const entriesByPath = /* @__PURE__ */ new Map();
+	const keysRecordedThisRun = /* @__PURE__ */ new Set();
+	let isLoaded = false;
+	const store = createJsonStateStore({
+		name: "owned paths ledger",
+		filePath,
+		parse: (raw) => OwnedPathsLedger.safeParse(raw).data ?? null,
+		adopt: (ledger) => {
+			entriesByPath.clear();
+			for (const entry of ledger?.entries ?? []) entriesByPath.set(ledgerKey(entry.path), entry);
+			isLoaded = true;
+		},
+		warn: (message, fields) => log.warn(`[owned-paths] ${message} ${JSON.stringify(fields)}`)
+	});
+	async function persist() {
+		const ledger = {
+			version: 1,
+			entries: [...entriesByPath.values()]
+		};
+		await store.write(ledger, () => `${JSON.stringify(ledger, null, 2)}\n`);
+	}
+	async function record(entry) {
+		await store.load();
+		if (!isLoaded) return;
+		const canonicalEntry = {
+			...entry,
+			path: await canonicalOwnedPath(entry.path)
+		};
+		const canonicalKey = ledgerKey(canonicalEntry.path);
+		keysRecordedThisRun.add(canonicalKey);
+		entriesByPath.set(canonicalKey, canonicalEntry);
+		await persist();
+	}
+	async function forget(ownedPath) {
+		await store.load();
+		if (!isLoaded || !entriesByPath.delete(ledgerKey(await canonicalOwnedPath(ownedPath)))) return;
+		await persist();
+	}
+	async function loadEarlierRunEntries() {
+		await store.load();
+		if (!isLoaded) return { ok: false };
+		return {
+			ok: true,
+			entries: [...entriesByPath.entries()].filter(([key]) => !keysRecordedThisRun.has(key)).map(([, entry]) => entry)
+		};
+	}
+	return {
+		loadEarlierRunEntries,
+		record,
+		forget,
+		idle: () => store.idle()
+	};
+}
+async function pathExists$1(ownedPath) {
+	return fs$1.lstat(ownedPath).then(() => true, () => false);
+}
+async function holdsCheckout(folderPath) {
+	const children = await fs$1.readdir(folderPath).catch(() => []);
+	return (await Promise.all(children.map((child) => pathExists$1(path.join(folderPath, child, ".git"))))).includes(true);
+}
+async function removeOrphanedWorktree(entry, git, shareList) {
+	if (!entry.projectPath || !entry.branch) return "it names no repository and branch to check its work against";
+	const work = await git.describeWorkspaceMemberWork({
+		projectPath: entry.projectPath,
+		cwd: entry.path,
+		branch: entry.branch
+	});
+	if (work) return work;
+	const removed = await git.removeWorkspaceMember({
+		projectPath: entry.projectPath,
+		cwd: entry.path,
+		shareList
+	});
+	if (!removed.ok || await pathExists$1(entry.path)) return `git could not remove it: ${removed.err || "the folder is still there"}`;
+	return null;
+}
+async function removeOrphanedFolder(entry, ledger, keptPaths) {
+	if (holdsKeptPath(entry.path, keptPaths)) return "it holds a checkout that was kept";
+	if (await holdsCheckout(entry.path)) return "it still holds a checkout";
+	const removal = await fs$1.rm(entry.path, {
+		recursive: true,
+		force: true
+	}).then(() => null, (error) => `it could not be deleted: ${errorMessage(error)}`);
+	if (removal) return removal;
+	await ledger.forget(entry.path);
+	return null;
+}
+async function reconcileOwnedPaths({ ledger, configuredSessionIds, git, shareList, log = console }) {
+	const loaded = await ledger.loadEarlierRunEntries();
+	if (!loaded.ok) {
+		log.warn("[owned-paths] deleted nothing at startup because the owned paths ledger could not be read");
+		return;
+	}
+	const keptPaths = [];
+	for (const entry of orphanedOwnedPaths(loaded.entries, configuredSessionIds)) {
+		if (!await pathExists$1(entry.path)) {
+			await ledger.forget(entry.path);
+			continue;
+		}
+		const keepReason = entry.kind === "folder" ? await removeOrphanedFolder(entry, ledger, keptPaths) : await removeOrphanedWorktree(entry, git, shareList);
+		if (!keepReason) {
+			log.log(`[owned-paths] deleted ${entry.path}, left by ${entry.owner}`);
+			continue;
+		}
+		keptPaths.push(entry.path);
+		log.warn(`[owned-paths] kept ${entry.path}, left by ${entry.owner}, because ${keepReason}`);
+	}
+}
+//#endregion
 //#region server/core/restart-strategy.ts
 function decideRestartStrategy(env) {
 	const invocationId = env ? env.INVOCATION_ID : void 0;
@@ -1363,7 +1525,7 @@ function decideByteRange(rangeHeader, sizeBytes) {
 var CUSTOM_SOUNDS_ROUTE = "/custom-sounds";
 async function listCustomSounds(soundsDir) {
 	try {
-		return selectCustomSoundNames((await fsp.readdir(soundsDir, { withFileTypes: true })).map((entry) => ({
+		return selectCustomSoundNames((await fs$1.readdir(soundsDir, { withFileTypes: true })).map((entry) => ({
 			name: entry.name,
 			isFile: entry.isFile()
 		})));
@@ -1373,10 +1535,10 @@ async function listCustomSounds(soundsDir) {
 }
 async function resolveServableSound(soundsDir, name) {
 	try {
-		const realDirectory = await fsp.realpath(soundsDir);
-		const realFile = await fsp.realpath(path.join(soundsDir, name));
+		const realDirectory = await fs$1.realpath(soundsDir);
+		const realFile = await fs$1.realpath(path.join(soundsDir, name));
 		if (!isDirectChildOf$1(realDirectory, realFile)) return null;
-		const linkStats = await fsp.lstat(path.join(soundsDir, name));
+		const linkStats = await fs$1.lstat(path.join(soundsDir, name));
 		if (!linkStats.isFile()) return null;
 		return {
 			realFile,
@@ -1584,12 +1746,12 @@ function isStatuslineEvent(event) {
 async function sweepSessionUploads(dir, justWritten) {
 	let entries = null;
 	try {
-		entries = await fsp.readdir(dir);
+		entries = await fs$1.readdir(dir);
 	} catch {
 		return;
 	}
 	for (const name of planUploadRetention(entries, { justWritten })) try {
-		await fsp.unlink(path.join(dir, name));
+		await fs$1.unlink(path.join(dir, name));
 	} catch {}
 }
 function receiveUpload({ req, res, sess, dir, filename, savedPath }) {
@@ -1604,7 +1766,7 @@ function receiveUpload({ req, res, sess, dir, filename, savedPath }) {
 	let discardWanted = false;
 	let streamClosed = false;
 	const unlinkPartial = () => {
-		fsp.unlink(savedPath).catch(() => {});
+		fs$1.unlink(savedPath).catch(() => {});
 	};
 	const discardPartial = () => {
 		discardWanted = true;
@@ -1929,7 +2091,7 @@ function createBackendHttpApp(dependencies) {
 			abortedBeforeReceive = true;
 		};
 		req.on("error", markAbortedBeforeReceive);
-		fsp.mkdir(dir, {
+		fs$1.mkdir(dir, {
 			recursive: true,
 			mode: 448
 		}).then(() => {
@@ -1955,7 +2117,7 @@ function createBackendHttpApp(dependencies) {
 			return;
 		}
 		const savedPath = path.join(uploadsRoot, sessionId, filename);
-		fsp.lstat(savedPath).then((savedStat) => {
+		fs$1.lstat(savedPath).then((savedStat) => {
 			if (!savedStat.isFile()) {
 				res.status(404).end();
 				return;
@@ -5819,6 +5981,1006 @@ function decideMarkerBase({ marker, fallbackBase, configuredIntegrationBranch, d
 	};
 }
 //#endregion
+//#region shared/contracts/guardrails-launch.ts
+var GuardrailsLaunchLogin = z.object({
+	linkPath: z.string().min(1),
+	targetPath: z.string().min(1)
+}).strict();
+var GuardrailsLaunchOwner = z.object({
+	ownerPid: z.number().int().positive(),
+	ownerHost: z.string(),
+	ownerPidNamespace: z.string().nullable(),
+	ownsTempDir: z.boolean(),
+	keptTempFolderName: z.string().min(1).optional(),
+	logins: z.array(GuardrailsLaunchLogin),
+	placeholderPaths: z.array(z.string().min(1))
+}).strict();
+//#endregion
+//#region server/core/claude-trust-core.ts
+var CLAUDE_GLOBAL_CONFIG_FILE_NAME = ".claude.json";
+var CLAUDE_LEGACY_CONFIG_FILE_NAME = ".config.json";
+var CLAUDE_CONFIG_LOCK_SUFFIX = ".lock";
+var CLAUDE_CONFIG_LOCK_STALE_MS = 1e4;
+var CLAUDE_CONFIG_LOCK_RETRY_DELAYS_MS = Object.freeze([
+	200,
+	400,
+	800,
+	1600
+]);
+var GRANTED_KEYS = Object.freeze([
+	"hasTrustDialogAccepted",
+	"hasClaudeMdExternalIncludesApproved",
+	"hasClaudeMdExternalIncludesWarningShown"
+]);
+var TRUST_ONLY_KEYS = Object.freeze(["hasTrustDialogAccepted"]);
+function isPlainRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function newProjectEntry() {
+	return {
+		allowedTools: [],
+		mcpContextUris: [],
+		mcpServers: {},
+		enabledMcpjsonServers: [],
+		disabledMcpjsonServers: []
+	};
+}
+function listClaudeGlobalConfigPathCandidates(env, homeDir) {
+	const configuredDir = env.CLAUDE_CONFIG_DIR?.trim();
+	const legacyConfigHome = (configuredDir || path.join(homeDir, ".claude")).normalize("NFC");
+	return [path.join(legacyConfigHome, CLAUDE_LEGACY_CONFIG_FILE_NAME), path.join(configuredDir || homeDir, CLAUDE_GLOBAL_CONFIG_FILE_NAME)];
+}
+function claudeProjectKeyOf(folderPath, platform) {
+	if (platform !== "win32") return path.posix.normalize(folderPath);
+	return path.win32.normalize(folderPath).replaceAll("\\", "/");
+}
+function repositoryRootOfCommonGitDir(commonGitDir) {
+	if (!path.isAbsolute(commonGitDir) || path.basename(commonGitDir) !== ".git") return null;
+	return path.dirname(commonGitDir);
+}
+function isConfigLockStale(lockModifiedMs, nowMs) {
+	return nowMs - lockModifiedMs > CLAUDE_CONFIG_LOCK_STALE_MS;
+}
+function hasRecordedExternalImportsDecline(existingEntry) {
+	return existingEntry?.hasClaudeMdExternalIncludesWarningShown === true && existingEntry.hasClaudeMdExternalIncludesApproved !== true;
+}
+function decideFolderTrust(configText, repositoryRoot, platform) {
+	const projectKey = claudeProjectKeyOf(repositoryRoot, platform);
+	let config;
+	try {
+		config = JSON.parse(configText);
+	} catch {
+		return {
+			kind: "unreadable",
+			reason: "it is not valid JSON"
+		};
+	}
+	if (!isPlainRecord(config)) return {
+		kind: "unreadable",
+		reason: "it is not a JSON object"
+	};
+	const projects = config.projects ?? {};
+	if (!isPlainRecord(projects)) return {
+		kind: "unreadable",
+		reason: "its projects key is not an object"
+	};
+	const existingEntry = projects[projectKey];
+	if (existingEntry !== void 0 && !isPlainRecord(existingEntry)) return {
+		kind: "unreadable",
+		reason: "its entry for this folder is not an object"
+	};
+	const keysToGrant = hasRecordedExternalImportsDecline(existingEntry) ? TRUST_ONLY_KEYS : GRANTED_KEYS;
+	if (keysToGrant.every((key) => existingEntry?.[key] === true)) return { kind: "trusted" };
+	const trustedEntry = {
+		...existingEntry ?? newProjectEntry(),
+		...Object.fromEntries(keysToGrant.map((key) => [key, true]))
+	};
+	const nextConfigText = JSON.stringify({
+		...config,
+		projects: {
+			...projects,
+			[projectKey]: trustedEntry
+		}
+	}, null, 2);
+	return {
+		kind: "grant",
+		nextConfigText: configText.endsWith("\n") ? `${nextConfigText}\n` : nextConfigText
+	};
+}
+//#endregion
+//#region server/guardrails/core/guardrails-bridge-socket-core.ts
+var LONGEST_BRIDGE_SOCKET_NAME = "claude-socks-0123456789abcdef.sock";
+var UNIX_SOCKET_PATH_BYTE_LIMIT = 107;
+var SHORT_BRIDGE_SOCKET_FOLDER = "/tmp";
+function bridgeSocketPathBytes(tempDirectory) {
+	return Buffer.byteLength(path.join(tempDirectory, LONGEST_BRIDGE_SOCKET_NAME));
+}
+function hasRoomForBridgeSocket(tempDirectory, platform) {
+	return platform !== "linux" || bridgeSocketPathBytes(tempDirectory) <= UNIX_SOCKET_PATH_BYTE_LIMIT;
+}
+function bridgeSocketLauncherEnv(inheritedTempDirectory, platform) {
+	if (hasRoomForBridgeSocket(inheritedTempDirectory, platform)) return { TMPDIR: inheritedTempDirectory };
+	return { TMPDIR: SHORT_BRIDGE_SOCKET_FOLDER };
+}
+//#endregion
+//#region server/guardrails/core/guardrails-policy-core.ts
+var VENDOR_PROFILES = Object.freeze({
+	claude: {
+		homeEntries: [".claude", ".claude.json"],
+		launchWritableFolders: ({ cwd, agentSessionId }) => [path.join("projects", encodeProjectDir(cwd)), ...agentSessionId === null ? [] : [path.join("session-env", agentSessionId)]],
+		launchPrivateFolders: ["shell-snapshots"],
+		launchHomeEnvName: null,
+		loginFiles: [".credentials.json"],
+		configEntries: [
+			"settings.json",
+			"settings.local.json",
+			"hooks",
+			"skills",
+			"plugins",
+			"commands",
+			"agents",
+			"CLAUDE.md",
+			"AGENTS.md"
+		],
+		apiDomains: ["api.anthropic.com", "platform.claude.com"],
+		launchEnv: { DISABLE_AUTOUPDATER: "1" }
+	},
+	codex: {
+		homeEntries: [".codex"],
+		launchWritableFolders: () => [],
+		launchPrivateFolders: [],
+		launchHomeEnvName: "CODEX_HOME",
+		loginFiles: ["auth.json"],
+		configEntries: [
+			"config.toml",
+			"AGENTS.md",
+			"skills",
+			"rules",
+			"prompts",
+			"hooks.json"
+		],
+		apiDomains: [
+			"chatgpt.com",
+			"*.chatgpt.com",
+			"auth.openai.com",
+			"api.openai.com",
+			"*.openai.com"
+		],
+		launchEnv: {}
+	}
+});
+var GUARDRAILS_VENDORS = Object.freeze(["claude", "codex"]);
+var UNWRAPPED_VENDOR_HOME_ENTRIES = Object.freeze([".grok"]);
+var CREDENTIAL_HOME_ENTRIES = Object.freeze([
+	".ssh",
+	".config/gh",
+	".config/coderv2",
+	"Library/Application Support/coderv2",
+	"Library/Keychains",
+	".git-credentials"
+]);
+var CLOUD_CREDENTIAL_HOME_ENTRIES = Object.freeze([
+	".aws",
+	".azure",
+	".config/gcloud",
+	".kube",
+	".docker",
+	".gnupg",
+	".netrc",
+	".npmrc"
+]);
+var STANDARD_LEVEL_USABLE_CREDENTIAL_ENTRIES = Object.freeze(["Library/Keychains"]);
+var XDG_CONFIG_DEFAULT_HOME_PREFIX = ".config/";
+var SHARED_TEMP_DIRS = Object.freeze(["/tmp/claude", "/private/tmp/claude"]);
+var SHARED_HOME_WRITE_ENTRIES = Object.freeze([".npm/_logs"]);
+var GUARDRAILS_PLACEHOLDER_NAMES = Object.freeze([
+	".bash_profile",
+	".bashrc",
+	".claude",
+	".gitconfig",
+	".gitmodules",
+	".idea",
+	".mcp.json",
+	".profile",
+	".ripgreprc",
+	".vscode",
+	".zprofile",
+	".zshrc"
+]);
+var WHOLE_FILESYSTEM = "/";
+var GUARDRAILS_TEMP_FOLDER = "guardrails-temp";
+var AGENT_LOGINS_SIBLING_ENTRY = "agent-logins";
+var GLIMMERVOID_CONFIG_SIBLING_ENTRIES = Object.freeze([
+	AGENT_LOGINS_SIBLING_ENTRY,
+	"bin",
+	"pairings.json",
+	"pairings-seen.json",
+	"plans",
+	"telegram-outbox.json",
+	"traces",
+	"uploads",
+	"usage-budget-state.json",
+	"usage-lanes.json",
+	"usage-warehouse.json",
+	"visions-intent.json"
+]);
+var GLIMMERVOID_HOME_STATE_ENTRIES = Object.freeze([
+	"benchmark-runs",
+	"benchmarks",
+	"config.json",
+	"issues-cache.json",
+	"litellm-pricing.json",
+	"my-prs-state.json",
+	"my-prs-work",
+	"posthog-reports",
+	"posthog-state.json",
+	"posthog-work",
+	"recordings",
+	"guardrails-homes",
+	"guardrails-policies",
+	"sane-yolo",
+	"scratch",
+	"sounds",
+	"team-review-repos",
+	"team-review-state.json",
+	"team-review-work",
+	"team-review-worktrees",
+	"telemetry-pending-crash.json",
+	"telemetry.json",
+	"tmp",
+	"update-check.json",
+	"update-journal.json",
+	"workflows-state.json",
+	"workflows-work"
+]);
+var RUNTIME_MANDATORY_CLAUDE_DENY_FOLDERS = Object.freeze(["commands", "agents"]);
+var GUARDED_PROXY_BYPASS = "localhost,::1,169.254.0.0/16,10.0.0.0/8,172.16.0.0/12,192.168.0.0/16";
+var HOOK_LOOPBACK_HOST = "127.0.0.1";
+var AGENT_SESSION_ID_SHAPE = /^[A-Za-z0-9][A-Za-z0-9_-]{7,127}$/;
+var STANDARD_OPEN_NETWORK = Object.freeze({
+	allowAllUnixSockets: true,
+	allowMachLookup: ["*"]
+});
+var STRICT_OPEN_NETWORK = Object.freeze({ allowAllUnixSockets: false });
+function unique(entries) {
+	return [...new Set(entries)];
+}
+function literalEntries(entryPaths) {
+	return unique(entryPaths).map((entryPath) => ({
+		path: entryPath,
+		literal: true
+	}));
+}
+function homePaths(host, homeEntries) {
+	return homeEntries.map((entry) => path.join(host.homeDir, entry));
+}
+function isInsideAny(parents, child) {
+	return parents.some((parent) => isPathInside(parent, child));
+}
+function vendorStatePaths(host, vendor, stateFolderEntries) {
+	return stateFolderEntries.map((entry) => path.join(host.vendorLocations[vendor].stateFolder, entry));
+}
+function vendorHeldPaths(host, vendor) {
+	const { stateFolder, configFiles, otherHomes } = host.vendorLocations[vendor];
+	return [
+		stateFolder,
+		...configFiles,
+		...otherHomes
+	];
+}
+function launchHomeOf(host, vendor) {
+	return path.join(host.launchHomeDir, vendor);
+}
+function vendorsWithLaunchHome(role) {
+	if (role.vendorHome.scope === "state") return [];
+	return role.vendors.filter((vendor) => VENDOR_PROFILES[vendor].launchHomeEnvName !== null);
+}
+function vendorWritableFolders(role, host) {
+	const { vendorHome } = role;
+	if (vendorHome.scope === "state") return role.vendors.map((vendor) => host.vendorLocations[vendor].stateFolder);
+	return role.vendors.flatMap((vendor) => {
+		const profile = VENDOR_PROFILES[vendor];
+		if (profile.launchHomeEnvName !== null) return [launchHomeOf(host, vendor)];
+		return vendorStatePaths(host, vendor, profile.launchWritableFolders(vendorHome));
+	});
+}
+function launchPrivateFolders(role, host) {
+	if (role.vendorHome.scope === "state") return [];
+	return role.vendors.flatMap((vendor) => vendorStatePaths(host, vendor, VENDOR_PROFILES[vendor].launchPrivateFolders));
+}
+function launchHomeLinkCandidates(role, host) {
+	return vendorsWithLaunchHome(role).flatMap((vendor) => {
+		const { configEntries, loginFiles } = VENDOR_PROFILES[vendor];
+		const linkFor = (entry, isLogin) => ({
+			linkPath: path.join(launchHomeOf(host, vendor), entry),
+			targetPath: path.join(host.vendorLocations[vendor].stateFolder, entry),
+			isLogin
+		});
+		return [...configEntries.map((entry) => linkFor(entry, false)), ...loginFiles.map((entry) => linkFor(entry, true))];
+	});
+}
+function launchHomeEnv(role, host) {
+	return Object.fromEntries(vendorsWithLaunchHome(role).flatMap((vendor) => {
+		const envName = VENDOR_PROFILES[vendor].launchHomeEnvName;
+		return envName === null ? [] : [[envName, launchHomeOf(host, vendor)]];
+	}));
+}
+function vendorLoginFiles(role, host) {
+	return role.vendors.flatMap((vendor) => vendorStatePaths(host, vendor, VENDOR_PROFILES[vendor].loginFiles));
+}
+function roleWritableRoots(role) {
+	return [
+		...role.writableRoots,
+		...role.lockedCheckouts,
+		...role.commitCheckouts.flatMap(({ checkout, gitDir }) => [checkout, gitDir])
+	];
+}
+function alwaysWritablePaths(role, host) {
+	return [
+		host.tempDir,
+		...roleWritableRoots(role),
+		...vendorWritableFolders(role, host)
+	];
+}
+function commitCheckoutWriteDenies({ checkout, gitDir }) {
+	const gitPointer = path.join(checkout, ".git");
+	const gitDirDenies = [path.join(gitDir, "hooks"), path.join(gitDir, "config")];
+	if (path.resolve(gitPointer) === path.resolve(gitDir)) return gitDirDenies;
+	return [gitPointer, ...gitDirDenies];
+}
+function writeDeniesWhenPresent(role, host) {
+	const writablePaths = alwaysWritablePaths(role, host);
+	const sharedHomeWrites = homePaths(host, SHARED_HOME_WRITE_ENTRIES).filter((sharedPath) => !isInsideAny(roleWritableRoots(role), sharedPath));
+	const vendorConfig = role.vendors.flatMap((vendor) => [...vendorStatePaths(host, vendor, VENDOR_PROFILES[vendor].configEntries), ...host.vendorLocations[vendor].configFiles]).filter((configPath) => isInsideAny(writablePaths, configPath));
+	return [
+		...SHARED_TEMP_DIRS,
+		...sharedHomeWrites,
+		...vendorConfig,
+		...role.commitCheckouts.flatMap(commitCheckoutWriteDenies)
+	];
+}
+function lockedCheckoutWriteDenies(role) {
+	return role.lockedCheckouts.flatMap((checkout) => [path.join(checkout, ".git"), path.join(checkout, ".claude")]);
+}
+function lockedClaudeMountPoints(role) {
+	return role.lockedCheckouts.flatMap((checkout) => RUNTIME_MANDATORY_CLAUDE_DENY_FOLDERS.map((folder) => path.join(checkout, ".claude", folder)));
+}
+function guardrailsPlaceholderPaths(role) {
+	return unique([...(role.vendorHome.scope === "launch" ? [role.vendorHome.cwd] : []).flatMap((workingFolder) => GUARDRAILS_PLACEHOLDER_NAMES.map((placeholderName) => path.join(workingFolder, placeholderName))), ...lockedCheckoutWriteDenies(role)]);
+}
+function homeEntriesNamedLike(host, homeEntries) {
+	return host.homeEntryNames.filter((entryName) => homeEntries.some((homeEntry) => entryName.startsWith(homeEntry)));
+}
+function relocatedXdgConfigPaths(host, homeEntries) {
+	const xdgConfigHome = host.relocatedXdgConfigHome;
+	if (xdgConfigHome === null) return [];
+	return homeEntries.filter((entry) => entry.startsWith(XDG_CONFIG_DEFAULT_HOME_PREFIX)).map((entry) => path.join(xdgConfigHome, entry.slice(8)));
+}
+function isStandardLevel(role) {
+	return role.guardrailLevel === "standard";
+}
+function blockedCredentialHomeEntries(role) {
+	const credentialHomeEntries = [...CREDENTIAL_HOME_ENTRIES, ...CLOUD_CREDENTIAL_HOME_ENTRIES];
+	if (!isStandardLevel(role)) return credentialHomeEntries;
+	return credentialHomeEntries.filter((entry) => !STANDARD_LEVEL_USABLE_CREDENTIAL_ENTRIES.includes(entry));
+}
+function credentialWriteBlocks(role, host) {
+	const credentialHomeEntries = blockedCredentialHomeEntries(role);
+	return [...homePaths(host, credentialHomeEntries), ...relocatedXdgConfigPaths(host, credentialHomeEntries)];
+}
+function glimmervoidStateWriteBlocks(role, host) {
+	const keptWritable = alwaysWritablePaths(role, host);
+	const configFolder = path.dirname(host.glimmervoidConfigFile);
+	const homeEntries = [
+		...GLIMMERVOID_HOME_STATE_ENTRIES,
+		...GLIMMERVOID_CONFIG_SIBLING_ENTRIES,
+		...host.glimmervoidHomeEntryNames
+	].map((entryName) => path.join(host.glimmervoidHome, entryName));
+	const configSiblings = GLIMMERVOID_CONFIG_SIBLING_ENTRIES.map((entryName) => path.join(configFolder, entryName));
+	return unique([
+		host.glimmervoidConfigFile,
+		...homeEntries,
+		...configSiblings
+	]).filter((entryPath) => !keptWritable.some((writable) => isPathInside(entryPath, writable)));
+}
+function standardWriteBlockCandidates(role, host) {
+	if (!isStandardLevel(role)) return [];
+	return unique([
+		...credentialWriteBlocks(role, host),
+		...glimmervoidStateWriteBlocks(role, host),
+		...role.blockedPaths ?? []
+	]);
+}
+function readDeniedPaths(role, host) {
+	const otherVendors = GUARDRAILS_VENDORS.filter((vendor) => !role.vendors.includes(vendor));
+	const otherVendorHomeEntries = [...otherVendors.flatMap((vendor) => VENDOR_PROFILES[vendor].homeEntries), ...UNWRAPPED_VENDOR_HOME_ENTRIES];
+	const credentialHomeEntries = blockedCredentialHomeEntries(role);
+	return [
+		...homePaths(host, [
+			...credentialHomeEntries,
+			...otherVendorHomeEntries,
+			...homeEntriesNamedLike(host, otherVendorHomeEntries)
+		]),
+		...relocatedXdgConfigPaths(host, credentialHomeEntries),
+		...otherVendors.flatMap((vendor) => vendorHeldPaths(host, vendor)),
+		...host.unwrappedVendorHomes,
+		host.glimmervoidHome,
+		path.join(path.dirname(host.glimmervoidConfigFile), AGENT_LOGINS_SIBLING_ENTRY),
+		...launchPrivateFolders(role, host),
+		...role.readDenied
+	];
+}
+function guardrailsPolicyProbePaths(role, host) {
+	return unique([
+		...writeDeniesWhenPresent(role, host),
+		...vendorLoginFiles(role, host),
+		...launchHomeLinkCandidates(role, host).map((link) => link.targetPath)
+	]);
+}
+function isValidPort(port) {
+	return Number.isInteger(port) && port >= 1 && port <= 65535;
+}
+function hostNamedPaths(host) {
+	const relocatedXdgConfigHomes = host.relocatedXdgConfigHome === null ? [] : [host.relocatedXdgConfigHome];
+	return [
+		host.homeDir,
+		host.glimmervoidHome,
+		host.glimmervoidConfigFile,
+		host.tempDir,
+		host.launchHomeDir,
+		...relocatedXdgConfigHomes,
+		...host.unwrappedVendorHomes,
+		...GUARDRAILS_VENDORS.flatMap((vendor) => vendorHeldPaths(host, vendor))
+	];
+}
+function guardrailsRoleRefusal(role, host) {
+	const launchCwds = role.vendorHome.scope === "launch" ? [role.vendorHome.cwd] : [];
+	const relativePath = [
+		...hostNamedPaths(host),
+		...roleWritableRoots(role),
+		...role.readDenied,
+		...role.readableWithinDenied,
+		...launchCwds
+	].find((namedPath) => !path.isAbsolute(namedPath));
+	if (relativePath !== void 0) return `guardrails policy path is not absolute: ${relativePath}`;
+	const rootOverProtectedHome = [...roleWritableRoots(role), ...vendorWritableFolders(role, host)].find((root) => isPathInside(root, host.homeDir) || isPathInside(root, host.glimmervoidHome));
+	if (rootOverProtectedHome !== void 0) return `writable root ${rootOverProtectedHome} contains the home folder or the Glimmervoid home`;
+	const writablePaths = alwaysWritablePaths(role, host);
+	const reallowedAncestor = role.readableWithinDenied.find((readable) => writablePaths.some((writable) => isPathInside(readable, writable, { allowEqual: false })));
+	if (reallowedAncestor !== void 0) return `readable path ${reallowedAncestor} is an ancestor of a writable root`;
+	if (role.network.access === "allowlist" && role.network.hookPort !== null && !isValidPort(role.network.hookPort)) return "hook listener port is invalid";
+	const agentSessionId = role.vendorHome.scope === "launch" ? role.vendorHome.agentSessionId : null;
+	if (agentSessionId !== null && !AGENT_SESSION_ID_SHAPE.test(agentSessionId)) return "agent session id is invalid";
+	return null;
+}
+function networkPolicy(role) {
+	if (role.network.access === "open") return isStandardLevel(role) ? { ...STANDARD_OPEN_NETWORK } : { ...STRICT_OPEN_NETWORK };
+	if (role.network.access === "none") return {
+		allowedDomains: [],
+		deniedDomains: [],
+		allowLocalBinding: false,
+		allowAllUnixSockets: false
+	};
+	const hookEndpoint = role.network.hookPort === null ? [] : [`${HOOK_LOOPBACK_HOST}:${role.network.hookPort}`];
+	const vendorDomains = role.vendors.flatMap((vendor) => VENDOR_PROFILES[vendor].apiDomains);
+	return {
+		allowedDomains: unique([
+			...hookEndpoint,
+			...vendorDomains,
+			...role.network.domains
+		]),
+		deniedDomains: [],
+		strictAllowlist: true,
+		allowLocalBinding: false,
+		allowAllUnixSockets: false
+	};
+}
+function guardedEnvFor(role, host) {
+	if (role.network.access === "allowlist") return {
+		NO_PROXY: GUARDED_PROXY_BYPASS,
+		no_proxy: GUARDED_PROXY_BYPASS,
+		[HOOK_VIA_GUARDRAILS_PROXY_ENV]: "1"
+	};
+	if (role.network.access === "open") return { TMPDIR: host.tempDir };
+	return {};
+}
+function filesystemWrites(role, host, writablePaths) {
+	if (isStandardLevel(role)) return {
+		allowWrite: literalEntries([WHOLE_FILESYSTEM, ...writablePaths]),
+		denyWrite: literalEntries(host.writeBlockedPaths)
+	};
+	const isPresent = (candidate) => host.existingPaths.has(candidate);
+	return {
+		allowWrite: literalEntries(writablePaths),
+		denyWrite: literalEntries([...writeDeniesWhenPresent(role, host).filter(isPresent), ...lockedCheckoutWriteDenies(role)])
+	};
+}
+function buildGuardrailsLaunchPlan(role, host) {
+	const refusal = guardrailsRoleRefusal(role, host);
+	if (refusal !== null) return {
+		ok: false,
+		reason: refusal
+	};
+	const isPresent = (candidate) => host.existingPaths.has(candidate);
+	const writablePaths = [...alwaysWritablePaths(role, host), ...vendorLoginFiles(role, host).filter(isPresent)];
+	const readDenied = readDeniedPaths(role, host);
+	const writableWithinDenied = writablePaths.filter((writable) => isInsideAny(readDenied, writable));
+	return {
+		ok: true,
+		plan: {
+			launcher: role.network.access === "open" ? "open-network" : "runtime-cli",
+			policy: {
+				network: networkPolicy(role),
+				filesystem: {
+					denyRead: literalEntries(readDenied),
+					allowRead: literalEntries([...writableWithinDenied, ...role.readableWithinDenied]),
+					...filesystemWrites(role, host, writablePaths)
+				},
+				terminalScope: isStandardLevel(role) ? "any" : "own",
+				allowAppleEvents: isStandardLevel(role)
+			},
+			launchEnv: Object.assign({ CLAUDE_CODE_TMPDIR: host.tempDir }, ...role.vendors.map((vendor) => VENDOR_PROFILES[vendor].launchEnv), launchHomeEnv(role, host)),
+			guardedEnv: guardedEnvFor(role, host),
+			requiredDirectories: unique([
+				host.tempDir,
+				...vendorWritableFolders(role, host),
+				...launchPrivateFolders(role, host)
+			]),
+			launchHomeLinks: launchHomeLinkCandidates(role, host).filter((link) => isPresent(link.targetPath))
+		}
+	};
+}
+//#endregion
+//#region server/prune-files.ts
+var MS_PER_DAY = 864e5;
+function idForEntry(entry, suffixes) {
+	for (const suffix of suffixes) {
+		if (suffix.length === 0) return entry;
+		if (entry.endsWith(suffix)) return entry.slice(0, -suffix.length);
+	}
+	return null;
+}
+async function pruneAgedFiles({ directory, suffixes, retainDays, now = Date.now(), isRetainedId = () => false, entryMode = "file", fsPromises = fs.promises }) {
+	let entries;
+	try {
+		entries = await fsPromises.readdir(directory);
+	} catch {
+		return [];
+	}
+	const cutoff = now - retainDays * MS_PER_DAY;
+	const removedIds = [];
+	for (const entry of entries) {
+		const id = idForEntry(entry, suffixes);
+		if (!id || isRetainedId(id)) continue;
+		const filePath = path.join(directory, entry);
+		try {
+			if ((await fsPromises.stat(filePath)).mtimeMs >= cutoff) continue;
+			if (entryMode === "directory") await fsPromises.rm(filePath, {
+				recursive: true,
+				force: true
+			});
+			if (entryMode === "file") await fsPromises.unlink(filePath);
+			removedIds.push(id);
+		} catch {}
+	}
+	return removedIds;
+}
+//#endregion
+//#region server/guardrails/guardrails-launch.ts
+var LAUNCH_ID_SHAPE = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+var GUARDED_ENV_COMMAND = "/usr/bin/env";
+var POLICY_FOLDER = "guardrails-policies";
+var LAUNCH_HOME_FOLDER = "guardrails-homes";
+var START_FOLDER = "start";
+var OWNER_FILE_SUFFIX = ".owner.json";
+var ENTER_FOLDER_SCRIPT = "cd \"$1\" && shift && exec \"$@\"";
+var LOGIN_FILE_MODE = 384;
+var ABSENT_PATH_DENY_PLATFORM = "darwin";
+var OWN_PID_NAMESPACE_LINK = "/proc/self/ns/pid";
+var SESSION_TEMP_RETAIN_DAYS = 7;
+async function isPresent(candidate) {
+	try {
+		await access(candidate);
+		return true;
+	} catch (error) {
+		if (!isMissingFileError(error)) throw error;
+		return false;
+	}
+}
+async function presentPaths$1(candidates) {
+	const presence = await Promise.all(candidates.map(isPresent));
+	return new Set(candidates.filter((_candidate, index) => presence[index]));
+}
+async function realPathWhenPresent(candidate) {
+	if (!path.isAbsolute(candidate)) return candidate;
+	try {
+		return await realpath(candidate);
+	} catch (error) {
+		if (!isMissingFileError(error)) throw error;
+		return candidate;
+	}
+}
+function realPathsWhenPresent(candidates) {
+	return Promise.all(candidates.map(realPathWhenPresent));
+}
+async function symlinkTargetsInside(folder) {
+	const symlinkEntries = (await readdir(folder, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isSymbolicLink());
+	return (await Promise.all(symlinkEntries.map((entry) => realpath(path.join(folder, entry.name)).catch(() => null)))).filter((target) => target !== null);
+}
+async function blockedPathsWithRealTargets(candidates, operatorBlockedPaths) {
+	const resolved = await Promise.all(candidates.map(async (candidate) => {
+		const isPresentEntry = await lstat(candidate).then(() => true, (error) => !isMissingFileError(error));
+		const isKeptWhenAbsent = process.platform === ABSENT_PATH_DENY_PLATFORM || operatorBlockedPaths.includes(candidate);
+		if (!isPresentEntry) return isKeptWhenAbsent ? [candidate] : [];
+		const realCandidate = await realpath(candidate).catch(() => candidate);
+		return [
+			candidate,
+			realCandidate,
+			...await symlinkTargetsInside(realCandidate)
+		];
+	}));
+	return [...new Set(resolved.flat())];
+}
+async function configuredConfigFile(glimmervoidHome) {
+	const { envPath, homePath } = decideConfigPath({
+		env: process.env,
+		homeDir: glimmervoidHome
+	}, () => false);
+	const configFile = envPath ?? homePath;
+	return path.join(await realPathWhenPresent(path.dirname(configFile)), path.basename(configFile));
+}
+function scannedClaudeHomes(env, homeDir) {
+	return [env, {
+		...env,
+		CLAUDE_CONFIG_DIR: void 0
+	}].flatMap((scannedEnv) => projectDirCandidates(scannedEnv, [], homeDir)).map((projectsDir) => path.dirname(projectsDir));
+}
+async function resolveVendorLocations(env, homeDir) {
+	const [legacyClaudeConfigPath, claudeConfigPath] = listClaudeGlobalConfigPathCandidates(env, homeDir);
+	const [codexStateFolder, ...otherCodexHomes] = codexHomes(env, homeDir);
+	if (codexStateFolder === void 0) return null;
+	return {
+		claude: {
+			stateFolder: await realPathWhenPresent(path.dirname(legacyClaudeConfigPath)),
+			configFiles: [await realPathWhenPresent(claudeConfigPath)],
+			otherHomes: await realPathsWhenPresent(scannedClaudeHomes(env, homeDir))
+		},
+		codex: {
+			stateFolder: await realPathWhenPresent(codexStateFolder),
+			configFiles: [],
+			otherHomes: await realPathsWhenPresent(otherCodexHomes)
+		}
+	};
+}
+async function withRealRoots(role) {
+	const [writableRoots, lockedCheckouts, commitCheckouts] = await Promise.all([
+		Promise.all(role.writableRoots.map((root) => realpath(root))),
+		Promise.all(role.lockedCheckouts.map((checkout) => realpath(checkout))),
+		Promise.all(role.commitCheckouts.map(async ({ checkout, gitDir }) => ({
+			checkout: await realpath(checkout),
+			gitDir: await realpath(gitDir)
+		})))
+	]);
+	const vendorHome = role.vendorHome.scope === "launch" ? {
+		...role.vendorHome,
+		cwd: await realPathWhenPresent(role.vendorHome.cwd)
+	} : role.vendorHome;
+	return {
+		...role,
+		vendorHome,
+		writableRoots,
+		lockedCheckouts,
+		commitCheckouts,
+		readableWithinDenied: await realPathsWhenPresent(role.readableWithinDenied)
+	};
+}
+async function lstatWhenPresent(candidate) {
+	try {
+		return await lstat(candidate);
+	} catch (error) {
+		if (!isMissingFileError(error)) throw error;
+		return null;
+	}
+}
+async function isRegularFile(candidate) {
+	return (await lstatWhenPresent(candidate))?.isFile() ?? false;
+}
+async function isRealDirectory$1(candidate) {
+	return (await lstatWhenPresent(candidate))?.isDirectory() ?? false;
+}
+async function absentPaths(candidates) {
+	const presentCandidates = await presentPaths$1(candidates);
+	return candidates.filter((candidate) => !presentCandidates.has(candidate));
+}
+async function removeLeftoverPlaceholders(placeholderPaths) {
+	for (const placeholderPath of placeholderPaths) {
+		const placeholderStats = await lstat(placeholderPath).catch(() => null);
+		if (placeholderStats?.isFile() && placeholderStats.size === 0) await rm(placeholderPath, { force: true });
+	}
+}
+async function createMissingMountPoints(mountPoints) {
+	for (const mountPoint of mountPoints) {
+		if (!await isRealDirectory$1(path.dirname(mountPoint))) continue;
+		await mkdir(mountPoint).catch((error) => {
+			if (errorCode(error) !== "EEXIST") throw error;
+		});
+	}
+}
+async function isNewerThanTarget(linkPath, targetPath) {
+	const targetStats = await stat(targetPath).catch(() => null);
+	if (targetStats === null) return true;
+	return (await lstat(linkPath)).mtimeMs > targetStats.mtimeMs;
+}
+async function keepRefreshedLogins(logins, launchId, { onlyWhenNewer }) {
+	for (const { linkPath, targetPath } of logins) {
+		if (!await isRegularFile(linkPath)) continue;
+		if (onlyWhenNewer && !await isNewerThanTarget(linkPath, targetPath)) continue;
+		const stagedPath = `${targetPath}.${launchId}`;
+		await copyFile(linkPath, stagedPath);
+		await chmod(stagedPath, LOGIN_FILE_MODE);
+		await rename(stagedPath, targetPath);
+	}
+}
+async function removeLaunch(folders, owner, launchId, { onlyNewerLogins }) {
+	await rm(folders.policyPath, { force: true });
+	await removeLeftoverPlaceholders(owner.placeholderPaths);
+	await keepRefreshedLogins(owner.logins.filter((login) => isPathInside(folders.launchHomeDir, login.linkPath, { allowEqual: false })), launchId, { onlyWhenNewer: onlyNewerLogins });
+	await rm(folders.launchHomeDir, {
+		recursive: true,
+		force: true
+	});
+	if (folders.ownedTempDir !== null) await rm(folders.ownedTempDir, {
+		recursive: true,
+		force: true
+	});
+	await rm(folders.ownerPath, { force: true });
+}
+function isProcessAlive$1(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return errorCode(error) === "EPERM";
+	}
+}
+function readOwnPidNamespace() {
+	return readlink(OWN_PID_NAMESPACE_LINK).catch(() => null);
+}
+async function readOwnerFile(ownerPath) {
+	const outcome = await loadJsonStateFile({
+		filePath: ownerPath,
+		quarantine: false,
+		parse: (raw) => GuardrailsLaunchOwner.safeParse(raw).data ?? null
+	});
+	return outcome.status === "loaded" ? outcome.value : null;
+}
+async function sweepOrphanedGuardrailsLaunches(log = console) {
+	try {
+		const policyDir = path.join(glimmervoidHomeDir$1(), POLICY_FOLDER);
+		const entryNames = await readdir(policyDir).catch((error) => {
+			if (isMissingFileError(error)) return [];
+			throw error;
+		});
+		const glimmervoidHome = await realpath(glimmervoidHomeDir$1());
+		const sweeperPidNamespace = await readOwnPidNamespace();
+		let removedLaunchCount = 0;
+		for (const entryName of entryNames) {
+			if (!entryName.endsWith(OWNER_FILE_SUFFIX)) continue;
+			const launchId = entryName.slice(0, -11);
+			if (!LAUNCH_ID_SHAPE.test(launchId)) continue;
+			const ownerPath = path.join(policyDir, entryName);
+			const owner = await readOwnerFile(ownerPath);
+			if (owner === null || owner.ownerHost !== os.hostname() || owner.ownerPidNamespace !== sweeperPidNamespace || isProcessAlive$1(owner.ownerPid)) continue;
+			try {
+				await removeLaunch({
+					policyPath: path.join(policyDir, `${launchId}.json`),
+					ownerPath,
+					launchHomeDir: path.join(glimmervoidHome, LAUNCH_HOME_FOLDER, launchId),
+					ownedTempDir: owner.ownsTempDir ? path.join(glimmervoidHome, GUARDRAILS_TEMP_FOLDER, launchId) : null
+				}, owner, launchId, { onlyNewerLogins: true });
+				removedLaunchCount += 1;
+			} catch (error) {
+				log.warn(`[guardrails] could not remove the leftover launch ${launchId}: ${errorMessage(error)}`);
+			}
+		}
+		if (removedLaunchCount > 0) log.log(`[guardrails] removed ${removedLaunchCount} launch folders left by sessions that ended without a clean shutdown`);
+	} catch (error) {
+		log.warn(`[guardrails] could not sweep leftover launch folders: ${errorMessage(error)}`);
+	}
+}
+async function pruneLeftoverSessionTempFolders(glimmervoidHome, liveSessionIds, log = console) {
+	const policyEntryNames = await readdir(path.join(glimmervoidHome, POLICY_FOLDER)).catch((error) => {
+		if (isMissingFileError(error)) return [];
+		log.warn(`[guardrails] kept every session temp folder because the launch list could not be read: ${errorMessage(error)}`);
+		return null;
+	});
+	if (policyEntryNames === null) return;
+	const ownerEntryNames = policyEntryNames.filter((entryName) => entryName.endsWith(OWNER_FILE_SUFFIX));
+	const owners = await Promise.all(ownerEntryNames.map((entryName) => readOwnerFile(path.join(glimmervoidHome, POLICY_FOLDER, entryName))));
+	const tempFolderNamesWithOwners = /* @__PURE__ */ new Set([...ownerEntryNames.map((entryName) => entryName.slice(0, -11)), ...owners.flatMap((owner) => owner?.keptTempFolderName === void 0 ? [] : [owner.keptTempFolderName])]);
+	await pruneAgedFiles({
+		directory: path.join(glimmervoidHome, GUARDRAILS_TEMP_FOLDER),
+		suffixes: [""],
+		retainDays: SESSION_TEMP_RETAIN_DAYS,
+		entryMode: "directory",
+		isRetainedId: (id) => liveSessionIds.has(id) || tempFolderNamesWithOwners.has(id)
+	});
+}
+function launcherCommand(plan, policyPath) {
+	if (plan.launcher === "open-network") return {
+		file: process.execPath,
+		args: [relayPath("guardrails-open-launcher"), policyPath]
+	};
+	const runtimeCliPath = resolvePackageBin("@anthropic-ai/sandbox-runtime", "srt");
+	if (!runtimeCliPath) return null;
+	return {
+		file: process.execPath,
+		args: [
+			runtimeCliPath,
+			"--settings",
+			policyPath,
+			"--"
+		]
+	};
+}
+function guardedEnvPrefix(plan) {
+	const assignments = Object.entries(plan.guardedEnv).map(([name, value]) => `${name}=${value}`);
+	return assignments.length === 0 ? [] : [GUARDED_ENV_COMMAND, ...assignments];
+}
+function enteringFolder(enterDir, file, args) {
+	if (enterDir === void 0) return [file, ...args];
+	return [
+		"/bin/sh",
+		"-c",
+		ENTER_FOLDER_SCRIPT,
+		"sh",
+		enterDir,
+		file,
+		...args
+	];
+}
+function sessionTempFolderFor(sessionId) {
+	if (!LAUNCH_ID_SHAPE.test(sessionId)) return null;
+	return path.join(glimmervoidHomeDir$1(), GUARDRAILS_TEMP_FOLDER, sessionId);
+}
+async function removeSessionTempFolder(sessionId, log = console) {
+	const sessionTempFolder = sessionTempFolderFor(sessionId);
+	if (!sessionTempFolder) return;
+	await rm(sessionTempFolder, {
+		recursive: true,
+		force: true
+	}).catch((error) => log.warn(`[guardrails] could not delete session temp folder ${sessionTempFolder}: ${errorMessage(error)}`));
+}
+function launchTempDirFor(glimmervoidHome, launchId, tempDir, keptTempFolderName) {
+	if (tempDir !== void 0) return path.resolve(tempDir);
+	return path.join(glimmervoidHome, GUARDRAILS_TEMP_FOLDER, keptTempFolderName ?? launchId);
+}
+async function prepareGuardrailsLaunch({ role, launchId, tempDir, keptTempFolderName, enterDir }) {
+	if (!LAUNCH_ID_SHAPE.test(launchId)) return {
+		ok: false,
+		reason: "guardrails launch id is invalid"
+	};
+	if (keptTempFolderName !== void 0 && !LAUNCH_ID_SHAPE.test(keptTempFolderName)) return {
+		ok: false,
+		reason: "guardrails temp folder name is invalid"
+	};
+	try {
+		const policyDir = path.join(glimmervoidHomeDir$1(), POLICY_FOLDER);
+		await mkdir(policyDir, {
+			recursive: true,
+			mode: 448
+		});
+		const [homeDir, glimmervoidHome, realRole, ownerPidNamespace] = await Promise.all([
+			realpath(os.homedir()),
+			realpath(glimmervoidHomeDir$1()),
+			withRealRoots(role),
+			readOwnPidNamespace()
+		]);
+		const ownsTempDir = tempDir === void 0 && keptTempFolderName === void 0;
+		const launchTempDir = launchTempDirFor(glimmervoidHome, launchId, tempDir, keptTempFolderName);
+		const launchHomeDir = path.join(glimmervoidHome, LAUNCH_HOME_FOLDER, launchId);
+		const vendorLocations = await resolveVendorLocations(process.env, homeDir);
+		if (vendorLocations === null) return {
+			ok: false,
+			reason: "CODEX_HOME names no folder"
+		};
+		const xdgConfigHomeOverride = rawTextOr(process.env.XDG_CONFIG_HOME, null);
+		const stableHostPaths = {
+			homeDir,
+			glimmervoidHome,
+			glimmervoidConfigFile: await configuredConfigFile(glimmervoidHome),
+			tempDir: launchTempDir,
+			launchHomeDir,
+			vendorLocations,
+			unwrappedVendorHomes: await realPathsWhenPresent(grokHomes(process.env, homeDir)),
+			relocatedXdgConfigHome: xdgConfigHomeOverride === null ? null : await realPathWhenPresent(xdgConfigHomeOverride)
+		};
+		const buildPlanFromCurrentDisk = async () => {
+			const [homeEntryNames, glimmervoidHomeEntryNames] = await Promise.all([readdir(homeDir), readdir(glimmervoidHome)]);
+			const hostPaths = {
+				...stableHostPaths,
+				homeEntryNames,
+				glimmervoidHomeEntryNames
+			};
+			const [existingPaths, writeBlockedPaths] = await Promise.all([presentPaths$1(guardrailsPolicyProbePaths(realRole, hostPaths)), blockedPathsWithRealTargets(standardWriteBlockCandidates(realRole, hostPaths), realRole.blockedPaths ?? [])]);
+			return buildGuardrailsLaunchPlan(realRole, {
+				...hostPaths,
+				existingPaths,
+				writeBlockedPaths
+			});
+		};
+		const built = await buildPlanFromCurrentDisk();
+		if (!built.ok) return built;
+		const { plan } = built;
+		const policyPath = path.join(policyDir, `${launchId}.json`);
+		const launcher = launcherCommand(plan, policyPath);
+		if (!launcher) return {
+			ok: false,
+			reason: "the sandbox runtime CLI could not be resolved"
+		};
+		await Promise.all(plan.requiredDirectories.map((directory) => mkdir(directory, { recursive: true })));
+		const startDir = enterDir === void 0 ? void 0 : path.join(launchTempDir, START_FOLDER);
+		if (startDir !== void 0) await mkdir(startDir, { recursive: true });
+		await Promise.all(plan.launchHomeLinks.map((link) => symlink(link.targetPath, link.linkPath)));
+		await writeJsonAtomic(policyPath, plan.policy);
+		const folders = {
+			policyPath,
+			ownerPath: path.join(policyDir, `${launchId}${OWNER_FILE_SUFFIX}`),
+			launchHomeDir,
+			ownedTempDir: ownsTempDir ? launchTempDir : null
+		};
+		const owner = {
+			ownerPid: process.pid,
+			ownerHost: os.hostname(),
+			ownerPidNamespace,
+			ownsTempDir,
+			...keptTempFolderName === void 0 ? {} : { keptTempFolderName },
+			logins: plan.launchHomeLinks.filter((link) => link.isLogin).map(({ linkPath, targetPath }) => ({
+				linkPath,
+				targetPath
+			})),
+			placeholderPaths: []
+		};
+		await writeJsonAtomic(folders.ownerPath, owner);
+		const envPrefix = guardedEnvPrefix(plan);
+		return {
+			ok: true,
+			launch: {
+				wrap: async (file, args, { hasTerminal }) => {
+					const rebuilt = await buildPlanFromCurrentDisk();
+					if (!rebuilt.ok) throw new Error(rebuilt.reason);
+					await writeJsonAtomic(policyPath, {
+						...rebuilt.plan.policy,
+						allowPty: hasTerminal && rebuilt.plan.launcher === "open-network"
+					});
+					owner.placeholderPaths = await absentPaths(guardrailsPlaceholderPaths(realRole));
+					await writeJsonAtomic(folders.ownerPath, owner);
+					await createMissingMountPoints(lockedClaudeMountPoints(realRole));
+					return {
+						file: launcher.file,
+						args: [
+							...launcher.args,
+							...envPrefix,
+							...enteringFolder(enterDir, file, args)
+						]
+					};
+				},
+				env: {
+					...plan.launchEnv,
+					...bridgeSocketLauncherEnv(os.tmpdir(), process.platform)
+				},
+				...startDir === void 0 ? {} : { cwd: startDir },
+				dispose: () => removeLaunch(folders, owner, launchId, { onlyNewerLogins: false })
+			}
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			reason: errorMessage(error)
+		};
+	}
+}
+//#endregion
 //#region server/session/session-registry.ts
 function runAutoResume(sessions, config, spawnGate, logger = console) {
 	const ids = pickAutoResume(config.projects, config, Date.now());
@@ -5968,7 +7130,7 @@ function createSessionRegistry(dependencies) {
 		if (ingestLane) ingestLane.detachSessionTap(session);
 		if (ingestLane) ingestLane.releaseSessionRoots(session);
 		session.destroy();
-		Promise.resolve(session._killReap).catch(() => {}).then(() => session.discardWorktree?.()).catch(() => {});
+		Promise.resolve(session._killReap).catch(() => {}).then(() => session.discardWorktree?.()).catch(() => {}).then(() => removeSessionTempFolder(id, dependencies.logger));
 		sessions.delete(id);
 		capturedAgentFingerprints.delete(id);
 		dependencies.broadcastControl({
@@ -9233,8 +10395,10 @@ var QUICK_RETRY_DELAYS_MS = Object.freeze([
 	3e4,
 	9e4
 ]);
+var TRANSIENT_BACKOFF_MAX_MS = 3e5;
 function nextRetrySchedule({ failureStreak, quickRetryCount, quickRetries, retryAfterMs, baseMs, maxMs, random }) {
-	const quickRetryDelayMs = quickRetries && !(typeof retryAfterMs === "number" && Number.isFinite(retryAfterMs) && retryAfterMs > 0) ? QUICK_RETRY_DELAYS_MS[quickRetryCount] : void 0;
+	const hasRateLimitWait = typeof retryAfterMs === "number" && Number.isFinite(retryAfterMs) && retryAfterMs > 0;
+	const quickRetryDelayMs = quickRetries && !hasRateLimitWait ? QUICK_RETRY_DELAYS_MS[quickRetryCount] : void 0;
 	if (quickRetryDelayMs !== void 0) return {
 		waitMs: quickRetryDelayMs,
 		retry: {
@@ -9242,11 +10406,12 @@ function nextRetrySchedule({ failureStreak, quickRetryCount, quickRetries, retry
 			limit: QUICK_RETRY_DELAYS_MS.length
 		}
 	};
+	const backoffCeilingMs = quickRetries && !hasRateLimitWait ? Math.min(maxMs, TRANSIENT_BACKOFF_MAX_MS) : maxMs;
 	return {
 		waitMs: nextBackoffMs({
 			attempt: Math.max(1, failureStreak - quickRetryCount),
 			baseMs,
-			maxMs,
+			maxMs: backoffCeilingMs,
 			retryAfterMs,
 			random
 		}),
@@ -9302,434 +10467,6 @@ function buildLanePermissions({ denyTools = [], allowTools = [] } = {}) {
 	};
 }
 //#endregion
-//#region server/guardrails/core/guardrails-policy-core.ts
-var VENDOR_PROFILES = Object.freeze({
-	claude: {
-		homeEntries: [".claude", ".claude.json"],
-		launchWritableFolders: ({ cwd, agentSessionId }) => [path.join("projects", encodeProjectDir(cwd)), ...agentSessionId === null ? [] : [path.join("session-env", agentSessionId)]],
-		launchPrivateFolders: ["shell-snapshots"],
-		launchHomeEnvName: null,
-		loginFiles: [".credentials.json"],
-		configEntries: [
-			"settings.json",
-			"settings.local.json",
-			"hooks",
-			"skills",
-			"plugins",
-			"commands",
-			"agents",
-			"CLAUDE.md",
-			"AGENTS.md"
-		],
-		apiDomains: ["api.anthropic.com", "platform.claude.com"],
-		launchEnv: { DISABLE_AUTOUPDATER: "1" }
-	},
-	codex: {
-		homeEntries: [".codex"],
-		launchWritableFolders: () => [],
-		launchPrivateFolders: [],
-		launchHomeEnvName: "CODEX_HOME",
-		loginFiles: ["auth.json"],
-		configEntries: [
-			"config.toml",
-			"AGENTS.md",
-			"skills",
-			"rules",
-			"prompts",
-			"hooks.json"
-		],
-		apiDomains: [
-			"chatgpt.com",
-			"*.chatgpt.com",
-			"auth.openai.com",
-			"api.openai.com",
-			"*.openai.com"
-		],
-		launchEnv: {}
-	}
-});
-var GUARDRAILS_VENDORS = Object.freeze(["claude", "codex"]);
-var UNWRAPPED_VENDOR_HOME_ENTRIES = Object.freeze([".grok"]);
-var CREDENTIAL_HOME_ENTRIES = Object.freeze([
-	".ssh",
-	".config/gh",
-	".config/coderv2",
-	"Library/Application Support/coderv2",
-	"Library/Keychains",
-	".git-credentials"
-]);
-var CLOUD_CREDENTIAL_HOME_ENTRIES = Object.freeze([
-	".aws",
-	".azure",
-	".config/gcloud",
-	".kube",
-	".docker",
-	".gnupg",
-	".netrc",
-	".npmrc"
-]);
-var STANDARD_LEVEL_USABLE_CREDENTIAL_ENTRIES = Object.freeze(["Library/Keychains"]);
-var XDG_CONFIG_DEFAULT_HOME_PREFIX = ".config/";
-var SHARED_TEMP_DIRS = Object.freeze(["/tmp/claude", "/private/tmp/claude"]);
-var SHARED_HOME_WRITE_ENTRIES = Object.freeze([".npm/_logs"]);
-var GUARDRAILS_PLACEHOLDER_NAMES = Object.freeze([
-	".bash_profile",
-	".bashrc",
-	".claude",
-	".gitconfig",
-	".gitmodules",
-	".idea",
-	".mcp.json",
-	".profile",
-	".ripgreprc",
-	".vscode",
-	".zprofile",
-	".zshrc"
-]);
-var WHOLE_FILESYSTEM = "/";
-var GUARDRAILS_TEMP_FOLDER = "guardrails-temp";
-var AGENT_LOGINS_SIBLING_ENTRY = "agent-logins";
-var GLIMMERVOID_CONFIG_SIBLING_ENTRIES = Object.freeze([
-	AGENT_LOGINS_SIBLING_ENTRY,
-	"bin",
-	"pairings.json",
-	"pairings-seen.json",
-	"plans",
-	"telegram-outbox.json",
-	"traces",
-	"uploads",
-	"usage-budget-state.json",
-	"usage-lanes.json",
-	"usage-warehouse.json",
-	"visions-intent.json"
-]);
-var GLIMMERVOID_HOME_STATE_ENTRIES = Object.freeze([
-	"benchmark-runs",
-	"benchmarks",
-	"config.json",
-	"issues-cache.json",
-	"litellm-pricing.json",
-	"my-prs-state.json",
-	"my-prs-work",
-	"posthog-reports",
-	"posthog-state.json",
-	"posthog-work",
-	"recordings",
-	"guardrails-homes",
-	"guardrails-policies",
-	"sane-yolo",
-	"scratch",
-	"sounds",
-	"team-review-repos",
-	"team-review-state.json",
-	"team-review-work",
-	"team-review-worktrees",
-	"telemetry-pending-crash.json",
-	"telemetry.json",
-	"tmp",
-	"update-check.json",
-	"update-journal.json",
-	"workflows-state.json",
-	"workflows-work"
-]);
-var RUNTIME_MANDATORY_CLAUDE_DENY_FOLDERS = Object.freeze(["commands", "agents"]);
-var GUARDED_PROXY_BYPASS = "localhost,::1,169.254.0.0/16,10.0.0.0/8,172.16.0.0/12,192.168.0.0/16";
-var HOOK_LOOPBACK_HOST = "127.0.0.1";
-var AGENT_SESSION_ID_SHAPE = /^[A-Za-z0-9][A-Za-z0-9_-]{7,127}$/;
-var STANDARD_OPEN_NETWORK = Object.freeze({
-	allowAllUnixSockets: true,
-	allowMachLookup: ["*"]
-});
-var STRICT_OPEN_NETWORK = Object.freeze({ allowAllUnixSockets: false });
-function unique(entries) {
-	return [...new Set(entries)];
-}
-function literalEntries(entryPaths) {
-	return unique(entryPaths).map((entryPath) => ({
-		path: entryPath,
-		literal: true
-	}));
-}
-function homePaths(host, homeEntries) {
-	return homeEntries.map((entry) => path.join(host.homeDir, entry));
-}
-function isInsideAny(parents, child) {
-	return parents.some((parent) => isPathInside(parent, child));
-}
-function vendorStatePaths(host, vendor, stateFolderEntries) {
-	return stateFolderEntries.map((entry) => path.join(host.vendorLocations[vendor].stateFolder, entry));
-}
-function vendorHeldPaths(host, vendor) {
-	const { stateFolder, configFiles, otherHomes } = host.vendorLocations[vendor];
-	return [
-		stateFolder,
-		...configFiles,
-		...otherHomes
-	];
-}
-function launchHomeOf(host, vendor) {
-	return path.join(host.launchHomeDir, vendor);
-}
-function vendorsWithLaunchHome(role) {
-	if (role.vendorHome.scope === "state") return [];
-	return role.vendors.filter((vendor) => VENDOR_PROFILES[vendor].launchHomeEnvName !== null);
-}
-function vendorWritableFolders(role, host) {
-	const { vendorHome } = role;
-	if (vendorHome.scope === "state") return role.vendors.map((vendor) => host.vendorLocations[vendor].stateFolder);
-	return role.vendors.flatMap((vendor) => {
-		const profile = VENDOR_PROFILES[vendor];
-		if (profile.launchHomeEnvName !== null) return [launchHomeOf(host, vendor)];
-		return vendorStatePaths(host, vendor, profile.launchWritableFolders(vendorHome));
-	});
-}
-function launchPrivateFolders(role, host) {
-	if (role.vendorHome.scope === "state") return [];
-	return role.vendors.flatMap((vendor) => vendorStatePaths(host, vendor, VENDOR_PROFILES[vendor].launchPrivateFolders));
-}
-function launchHomeLinkCandidates(role, host) {
-	return vendorsWithLaunchHome(role).flatMap((vendor) => {
-		const { configEntries, loginFiles } = VENDOR_PROFILES[vendor];
-		const linkFor = (entry, isLogin) => ({
-			linkPath: path.join(launchHomeOf(host, vendor), entry),
-			targetPath: path.join(host.vendorLocations[vendor].stateFolder, entry),
-			isLogin
-		});
-		return [...configEntries.map((entry) => linkFor(entry, false)), ...loginFiles.map((entry) => linkFor(entry, true))];
-	});
-}
-function launchHomeEnv(role, host) {
-	return Object.fromEntries(vendorsWithLaunchHome(role).flatMap((vendor) => {
-		const envName = VENDOR_PROFILES[vendor].launchHomeEnvName;
-		return envName === null ? [] : [[envName, launchHomeOf(host, vendor)]];
-	}));
-}
-function vendorLoginFiles(role, host) {
-	return role.vendors.flatMap((vendor) => vendorStatePaths(host, vendor, VENDOR_PROFILES[vendor].loginFiles));
-}
-function roleWritableRoots(role) {
-	return [
-		...role.writableRoots,
-		...role.lockedCheckouts,
-		...role.commitCheckouts.flatMap(({ checkout, gitDir }) => [checkout, gitDir])
-	];
-}
-function alwaysWritablePaths(role, host) {
-	return [
-		host.tempDir,
-		...roleWritableRoots(role),
-		...vendorWritableFolders(role, host)
-	];
-}
-function commitCheckoutWriteDenies({ checkout, gitDir }) {
-	const gitPointer = path.join(checkout, ".git");
-	const gitDirDenies = [path.join(gitDir, "hooks"), path.join(gitDir, "config")];
-	if (path.resolve(gitPointer) === path.resolve(gitDir)) return gitDirDenies;
-	return [gitPointer, ...gitDirDenies];
-}
-function writeDeniesWhenPresent(role, host) {
-	const writablePaths = alwaysWritablePaths(role, host);
-	const sharedHomeWrites = homePaths(host, SHARED_HOME_WRITE_ENTRIES).filter((sharedPath) => !isInsideAny(roleWritableRoots(role), sharedPath));
-	const vendorConfig = role.vendors.flatMap((vendor) => [...vendorStatePaths(host, vendor, VENDOR_PROFILES[vendor].configEntries), ...host.vendorLocations[vendor].configFiles]).filter((configPath) => isInsideAny(writablePaths, configPath));
-	return [
-		...SHARED_TEMP_DIRS,
-		...sharedHomeWrites,
-		...vendorConfig,
-		...role.commitCheckouts.flatMap(commitCheckoutWriteDenies)
-	];
-}
-function lockedCheckoutWriteDenies(role) {
-	return role.lockedCheckouts.flatMap((checkout) => [path.join(checkout, ".git"), path.join(checkout, ".claude")]);
-}
-function lockedClaudeMountPoints(role) {
-	return role.lockedCheckouts.flatMap((checkout) => RUNTIME_MANDATORY_CLAUDE_DENY_FOLDERS.map((folder) => path.join(checkout, ".claude", folder)));
-}
-function guardrailsPlaceholderPaths(role) {
-	return unique([...(role.vendorHome.scope === "launch" ? [role.vendorHome.cwd] : []).flatMap((workingFolder) => GUARDRAILS_PLACEHOLDER_NAMES.map((placeholderName) => path.join(workingFolder, placeholderName))), ...lockedCheckoutWriteDenies(role)]);
-}
-function homeEntriesNamedLike(host, homeEntries) {
-	return host.homeEntryNames.filter((entryName) => homeEntries.some((homeEntry) => entryName.startsWith(homeEntry)));
-}
-function relocatedXdgConfigPaths(host, homeEntries) {
-	const xdgConfigHome = host.relocatedXdgConfigHome;
-	if (xdgConfigHome === null) return [];
-	return homeEntries.filter((entry) => entry.startsWith(XDG_CONFIG_DEFAULT_HOME_PREFIX)).map((entry) => path.join(xdgConfigHome, entry.slice(8)));
-}
-function isStandardLevel(role) {
-	return role.guardrailLevel === "standard";
-}
-function blockedCredentialHomeEntries(role) {
-	const credentialHomeEntries = [...CREDENTIAL_HOME_ENTRIES, ...CLOUD_CREDENTIAL_HOME_ENTRIES];
-	if (!isStandardLevel(role)) return credentialHomeEntries;
-	return credentialHomeEntries.filter((entry) => !STANDARD_LEVEL_USABLE_CREDENTIAL_ENTRIES.includes(entry));
-}
-function credentialWriteBlocks(role, host) {
-	const credentialHomeEntries = blockedCredentialHomeEntries(role);
-	return [...homePaths(host, credentialHomeEntries), ...relocatedXdgConfigPaths(host, credentialHomeEntries)];
-}
-function glimmervoidStateWriteBlocks(role, host) {
-	const keptWritable = alwaysWritablePaths(role, host);
-	const configFolder = path.dirname(host.glimmervoidConfigFile);
-	const homeEntries = [
-		...GLIMMERVOID_HOME_STATE_ENTRIES,
-		...GLIMMERVOID_CONFIG_SIBLING_ENTRIES,
-		...host.glimmervoidHomeEntryNames
-	].map((entryName) => path.join(host.glimmervoidHome, entryName));
-	const configSiblings = GLIMMERVOID_CONFIG_SIBLING_ENTRIES.map((entryName) => path.join(configFolder, entryName));
-	return unique([
-		host.glimmervoidConfigFile,
-		...homeEntries,
-		...configSiblings
-	]).filter((entryPath) => !keptWritable.some((writable) => isPathInside(entryPath, writable)));
-}
-function standardWriteBlockCandidates(role, host) {
-	if (!isStandardLevel(role)) return [];
-	return unique([
-		...credentialWriteBlocks(role, host),
-		...glimmervoidStateWriteBlocks(role, host),
-		...role.blockedPaths ?? []
-	]);
-}
-function readDeniedPaths(role, host) {
-	const otherVendors = GUARDRAILS_VENDORS.filter((vendor) => !role.vendors.includes(vendor));
-	const otherVendorHomeEntries = [...otherVendors.flatMap((vendor) => VENDOR_PROFILES[vendor].homeEntries), ...UNWRAPPED_VENDOR_HOME_ENTRIES];
-	const credentialHomeEntries = blockedCredentialHomeEntries(role);
-	return [
-		...homePaths(host, [
-			...credentialHomeEntries,
-			...otherVendorHomeEntries,
-			...homeEntriesNamedLike(host, otherVendorHomeEntries)
-		]),
-		...relocatedXdgConfigPaths(host, credentialHomeEntries),
-		...otherVendors.flatMap((vendor) => vendorHeldPaths(host, vendor)),
-		...host.unwrappedVendorHomes,
-		host.glimmervoidHome,
-		path.join(path.dirname(host.glimmervoidConfigFile), AGENT_LOGINS_SIBLING_ENTRY),
-		...launchPrivateFolders(role, host),
-		...role.readDenied
-	];
-}
-function guardrailsPolicyProbePaths(role, host) {
-	return unique([
-		...writeDeniesWhenPresent(role, host),
-		...vendorLoginFiles(role, host),
-		...launchHomeLinkCandidates(role, host).map((link) => link.targetPath)
-	]);
-}
-function isValidPort(port) {
-	return Number.isInteger(port) && port >= 1 && port <= 65535;
-}
-function hostNamedPaths(host) {
-	const relocatedXdgConfigHomes = host.relocatedXdgConfigHome === null ? [] : [host.relocatedXdgConfigHome];
-	return [
-		host.homeDir,
-		host.glimmervoidHome,
-		host.glimmervoidConfigFile,
-		host.tempDir,
-		host.launchHomeDir,
-		...relocatedXdgConfigHomes,
-		...host.unwrappedVendorHomes,
-		...GUARDRAILS_VENDORS.flatMap((vendor) => vendorHeldPaths(host, vendor))
-	];
-}
-function guardrailsRoleRefusal(role, host) {
-	const launchCwds = role.vendorHome.scope === "launch" ? [role.vendorHome.cwd] : [];
-	const relativePath = [
-		...hostNamedPaths(host),
-		...roleWritableRoots(role),
-		...role.readDenied,
-		...role.readableWithinDenied,
-		...launchCwds
-	].find((namedPath) => !path.isAbsolute(namedPath));
-	if (relativePath !== void 0) return `guardrails policy path is not absolute: ${relativePath}`;
-	const rootOverProtectedHome = [...roleWritableRoots(role), ...vendorWritableFolders(role, host)].find((root) => isPathInside(root, host.homeDir) || isPathInside(root, host.glimmervoidHome));
-	if (rootOverProtectedHome !== void 0) return `writable root ${rootOverProtectedHome} contains the home folder or the Glimmervoid home`;
-	const writablePaths = alwaysWritablePaths(role, host);
-	const reallowedAncestor = role.readableWithinDenied.find((readable) => writablePaths.some((writable) => isPathInside(readable, writable, { allowEqual: false })));
-	if (reallowedAncestor !== void 0) return `readable path ${reallowedAncestor} is an ancestor of a writable root`;
-	if (role.network.access === "allowlist" && role.network.hookPort !== null && !isValidPort(role.network.hookPort)) return "hook listener port is invalid";
-	const agentSessionId = role.vendorHome.scope === "launch" ? role.vendorHome.agentSessionId : null;
-	if (agentSessionId !== null && !AGENT_SESSION_ID_SHAPE.test(agentSessionId)) return "agent session id is invalid";
-	return null;
-}
-function networkPolicy(role) {
-	if (role.network.access === "open") return isStandardLevel(role) ? { ...STANDARD_OPEN_NETWORK } : { ...STRICT_OPEN_NETWORK };
-	if (role.network.access === "none") return {
-		allowedDomains: [],
-		deniedDomains: [],
-		allowLocalBinding: false,
-		allowAllUnixSockets: false
-	};
-	const hookEndpoint = role.network.hookPort === null ? [] : [`${HOOK_LOOPBACK_HOST}:${role.network.hookPort}`];
-	const vendorDomains = role.vendors.flatMap((vendor) => VENDOR_PROFILES[vendor].apiDomains);
-	return {
-		allowedDomains: unique([
-			...hookEndpoint,
-			...vendorDomains,
-			...role.network.domains
-		]),
-		deniedDomains: [],
-		strictAllowlist: true,
-		allowLocalBinding: false,
-		allowAllUnixSockets: false
-	};
-}
-function guardedEnvFor(role, host) {
-	if (role.network.access === "allowlist") return {
-		NO_PROXY: GUARDED_PROXY_BYPASS,
-		no_proxy: GUARDED_PROXY_BYPASS,
-		[HOOK_VIA_GUARDRAILS_PROXY_ENV]: "1"
-	};
-	if (role.network.access === "open") return { TMPDIR: host.tempDir };
-	return {};
-}
-function filesystemWrites(role, host, writablePaths) {
-	if (isStandardLevel(role)) return {
-		allowWrite: literalEntries([WHOLE_FILESYSTEM, ...writablePaths]),
-		denyWrite: literalEntries(host.writeBlockedPaths)
-	};
-	const isPresent = (candidate) => host.existingPaths.has(candidate);
-	return {
-		allowWrite: literalEntries(writablePaths),
-		denyWrite: literalEntries([...writeDeniesWhenPresent(role, host).filter(isPresent), ...lockedCheckoutWriteDenies(role)])
-	};
-}
-function buildGuardrailsLaunchPlan(role, host) {
-	const refusal = guardrailsRoleRefusal(role, host);
-	if (refusal !== null) return {
-		ok: false,
-		reason: refusal
-	};
-	const isPresent = (candidate) => host.existingPaths.has(candidate);
-	const writablePaths = [...alwaysWritablePaths(role, host), ...vendorLoginFiles(role, host).filter(isPresent)];
-	const readDenied = readDeniedPaths(role, host);
-	const writableWithinDenied = writablePaths.filter((writable) => isInsideAny(readDenied, writable));
-	return {
-		ok: true,
-		plan: {
-			launcher: role.network.access === "open" ? "open-network" : "runtime-cli",
-			policy: {
-				network: networkPolicy(role),
-				filesystem: {
-					denyRead: literalEntries(readDenied),
-					allowRead: literalEntries([...writableWithinDenied, ...role.readableWithinDenied]),
-					...filesystemWrites(role, host, writablePaths)
-				},
-				terminalScope: isStandardLevel(role) ? "any" : "own",
-				allowAppleEvents: isStandardLevel(role)
-			},
-			launchEnv: Object.assign({ CLAUDE_CODE_TMPDIR: host.tempDir }, ...role.vendors.map((vendor) => VENDOR_PROFILES[vendor].launchEnv), launchHomeEnv(role, host)),
-			guardedEnv: guardedEnvFor(role, host),
-			requiredDirectories: unique([
-				host.tempDir,
-				...vendorWritableFolders(role, host),
-				...launchPrivateFolders(role, host)
-			]),
-			launchHomeLinks: launchHomeLinkCandidates(role, host).filter((link) => isPresent(link.targetPath))
-		}
-	};
-}
-//#endregion
 //#region shared/my-pr-merge.ts
 var FAILING_CHECK_STATES$1 = /* @__PURE__ */ new Set(["FAILURE", "ERROR"]);
 function myPrMergeBlocker(pr) {
@@ -10500,6 +11237,7 @@ function createGithubStorePoller({ github, now, isDashboardConnected, exclusive,
 	let backoffUntil = 0;
 	let rateLimitedUntil = 0;
 	let failureStreak = 0;
+	let quickRetryCount = 0;
 	const unavailableKeys = /* @__PURE__ */ new Set();
 	function getSnapshot() {
 		const watchSnapshots = Object.fromEntries([...watches].map(([name, watch]) => [name, {
@@ -10568,19 +11306,21 @@ function createGithubStorePoller({ github, now, isDashboardConnected, exclusive,
 		const retryAfterMs = secondaryRateLimitWaitMs(pollingError) ?? void 0;
 		const schedule = nextRetrySchedule({
 			failureStreak,
-			quickRetryCount: 0,
-			quickRetries: false,
+			quickRetryCount,
+			quickRetries: true,
 			retryAfterMs,
 			baseMs: 6e4,
 			maxMs: GITHUB_RATE_LIMIT_WINDOW_MS,
 			random: () => 1
 		});
+		if (schedule.retry) quickRetryCount += 1;
 		backoffUntil = now() + schedule.waitMs;
 		rateLimitedUntil = retryAfterMs === void 0 ? 0 : backoffUntil;
 		log.warn(`[github-store] ${pollingError}`);
 		return {
 			failed: true,
-			retryAfterMs: schedule.waitMs
+			retryAfterMs: schedule.waitMs,
+			error: pollingError
 		};
 	}
 	function recordReadFailure(error) {
@@ -10589,6 +11329,7 @@ function createGithubStorePoller({ github, now, isDashboardConnected, exclusive,
 	function recordSuccess() {
 		pollingError = null;
 		failureStreak = 0;
+		quickRetryCount = 0;
 		backoffUntil = 0;
 		rateLimitedUntil = 0;
 	}
@@ -10787,11 +11528,15 @@ function createGithubStorePoller({ github, now, isDashboardConnected, exclusive,
 	function tick(watchNames) {
 		return exclusive(async () => {
 			const tickStartedAt = now();
-			if (shouldSkipTick({
+			if (watchNames !== void 0 && rateLimitedUntil > tickStartedAt) return {
+				failed: true,
+				retryAfterMs: rateLimitedUntil - tickStartedAt
+			};
+			if (watchNames === void 0 && shouldSkipTick({
 				now: tickStartedAt,
 				backoffUntil
 			})) return {
-				failed: watchNames !== void 0,
+				failed: false,
 				retryAfterMs: backoffUntil - tickStartedAt
 			};
 			const previousError = pollingError;
@@ -10825,7 +11570,7 @@ function createGithubStorePoller({ github, now, isDashboardConnected, exclusive,
 			} finally {
 				publishChanges([...details, ...behindChangedPrs], removedKeys, previousError, hasWatchChanges);
 			}
-		});
+		}, { isPriority: watchNames !== void 0 });
 	}
 	async function refreshWatches(names) {
 		if ((await tick(names)).failed) return {
@@ -11054,7 +11799,8 @@ function createGithubStorePoller({ github, now, isDashboardConnected, exclusive,
 function storeReadingLaneClock(clock) {
 	return clock ? {
 		schedule: clock.schedule,
-		exclusive: async (work) => work()
+		exclusive: async (work) => work(),
+		githubStatus: clock.githubStatus
 	} : void 0;
 }
 function createGithubStoreWiring({ github, clock, now = Date.now, isDashboardConnected, broadcast, log }) {
@@ -11137,6 +11883,8 @@ function createTickLoop({ tag, quickRetries = false, onScheduleChange = () => {}
 	let rateLimitedUntil = 0;
 	let isRefreshing = false;
 	let refreshNotice = null;
+	let lastRefreshedAt = null;
+	let hasTransientFailure = false;
 	const running = /* @__PURE__ */ new Set();
 	function persist() {
 		return persistQueue.run(() => writeState()).catch((e) => {
@@ -11165,14 +11913,17 @@ function createTickLoop({ tag, quickRetries = false, onScheduleChange = () => {}
 		retryTimer.unref?.();
 	}
 	function scheduleStatus() {
+		const incident = hasTransientFailure ? clock?.githubStatus?.incident() ?? null : null;
 		return {
 			nextAttemptAt,
 			retry,
 			isRefreshing,
-			refreshNotice
+			refreshNotice,
+			lastRefreshedAt,
+			incident
 		};
 	}
-	async function runTick(trigger) {
+	async function runTick(trigger, beforeTick) {
 		const isManual = trigger === "manual";
 		if (stopped) return {
 			ok: false,
@@ -11220,6 +11971,15 @@ function createTickLoop({ tag, quickRetries = false, onScheduleChange = () => {}
 					};
 				}
 			}
+			if (isManual && beforeTick) {
+				onScheduleChange();
+				const refreshed = await beforeTick();
+				if (stopped) return {
+					ok: false,
+					error: "Reviews polling is stopped."
+				};
+				if (!refreshed.ok) return refreshed;
+			}
 			clearRetryTimer();
 			nextAttemptAt = null;
 			retry = null;
@@ -11230,6 +11990,8 @@ function createTickLoop({ tag, quickRetries = false, onScheduleChange = () => {}
 				error: "Reviews polling is stopped."
 			};
 			if (outcome?.failed !== true) {
+				lastRefreshedAt = now();
+				hasTransientFailure = false;
 				failureStreak = 0;
 				quickRetryCount = 0;
 				backoffUntil = 0;
@@ -11238,6 +12000,8 @@ function createTickLoop({ tag, quickRetries = false, onScheduleChange = () => {}
 				return { ok: true };
 			}
 			failureStreak += 1;
+			hasTransientFailure = outcome.retryAfterMs === void 0;
+			if (hasTransientFailure) clock?.githubStatus?.noteTransientFailure();
 			const scheduled = nextRetrySchedule({
 				failureStreak,
 				quickRetryCount,
@@ -11250,7 +12014,7 @@ function createTickLoop({ tag, quickRetries = false, onScheduleChange = () => {}
 			if (scheduled.retry) quickRetryCount += 1;
 			if (outcome.retryAfterMs && outcome.retryAfterMs > 0) rateLimitedUntil = now() + outcome.retryAfterMs;
 			scheduleAttempt(scheduled.waitMs, scheduled.retry);
-			log.warn(`[${tag}] poll failed (${failureStreak} in a row) - backing off ${Math.round(scheduled.waitMs / 1e3)}s`);
+			log.warn(`[${tag}] poll failed (${failureStreak} in a row)${outcome.error ? `: ${outcome.error}` : ""} - backing off ${Math.round(scheduled.waitMs / 1e3)}s`);
 			return {
 				ok: false,
 				error: "Could not refresh from GitHub."
@@ -11270,8 +12034,8 @@ function createTickLoop({ tag, quickRetries = false, onScheduleChange = () => {}
 		if (tickRunning) return;
 		runTick("interval");
 	}
-	function refresh() {
-		return runTick("manual");
+	function refresh(beforeTick) {
+		return runTick("manual", beforeTick);
 	}
 	async function start(prelude = null) {
 		stopped = false;
@@ -11429,9 +12193,13 @@ function createIssuesPoller(dependencies) {
 	}
 	async function failedOutcome(error) {
 		const waitMs = await rateLimitWaitMs() ?? secondaryRateLimitWaitMs(error);
-		return waitMs === null ? { failed: true } : {
+		return waitMs === null ? {
 			failed: true,
-			retryAfterMs: waitMs
+			error
+		} : {
+			failed: true,
+			retryAfterMs: waitMs,
+			error
 		};
 	}
 	async function runTick() {
@@ -11877,7 +12645,7 @@ async function runCommandSafely(command, args, { env, timeoutMs, signal }) {
 	}
 }
 async function readTextFileOrNull$1(filePath) {
-	return fsp.readFile(filePath, "utf8").catch(() => null);
+	return fs$1.readFile(filePath, "utf8").catch(() => null);
 }
 function sleepUnlessAborted(durationMs, signal) {
 	return new Promise((resolve) => {
@@ -16609,11 +17377,6 @@ async function writeWhenAbsent(filePath, contents) {
 var WORKSPACE_MAP_FILE = "AGENTS.md";
 var WORKSPACE_POINTER_FILE = "CLAUDE.md";
 var WORKSPACE_MAP_HASH_FILE = ".glimmervoid-map-hash";
-var GENERATED_WORKSPACE_FILES = /* @__PURE__ */ new Set([
-	WORKSPACE_MAP_FILE,
-	WORKSPACE_POINTER_FILE,
-	WORKSPACE_MAP_HASH_FILE
-]);
 function hashWorkspaceMap(contents) {
 	return crypto.createHash("sha256").update(contents).digest("hex");
 }
@@ -16634,15 +17397,20 @@ async function writeWorkspaceMap(folder, contents) {
 	await fs.promises.writeFile(mapPath, contents);
 	await fs.promises.writeFile(hashPath, `${renderedHash}\n`);
 }
-function createSessionWorkspaceMembers({ plan, sessionName, shareList, gitWorkspace }) {
+function createSessionWorkspaceMembers({ plan, owner, sessionName, shareList, gitWorkspace }) {
 	let activeProvision = null;
 	async function provisionBody() {
 		try {
 			await fs.promises.mkdir(plan.folder, { recursive: true });
+			await gitWorkspace.recordOwnedFolder({
+				folderPath: plan.folder,
+				owner
+			});
 			const members = [];
 			for (const member of plan.members) {
 				const ensured = await gitWorkspace.ensureWorkspaceMember({
 					projectPath: member.repoPath,
+					owner,
 					wtDir: member.dir,
 					branch: plan.branch,
 					shareList
@@ -16682,28 +17450,68 @@ function createSessionWorkspaceMembers({ plan, sessionName, shareList, gitWorksp
 		});
 		return attempt;
 	}
-	async function release({ keepRepoPaths = [] } = {}) {
+	const pathExists = (candidatePath) => fs.promises.stat(candidatePath).then(() => true, () => false);
+	async function findMemberWork(member) {
+		return gitWorkspace.describeWorkspaceMemberWork({
+			projectPath: member.repoPath,
+			cwd: member.dir,
+			branch: plan.branch
+		}).catch((error) => `its work could not be checked: ${errorMessage(error)}`);
+	}
+	async function findKeptWork() {
+		if (activeProvision) await activeProvision;
+		const kept = [];
+		for (const member of plan.members) {
+			if (!await pathExists(member.dir)) continue;
+			const reason = await findMemberWork(member);
+			if (reason) kept.push({
+				path: member.dir,
+				reason
+			});
+		}
+		return kept;
+	}
+	async function releaseMember(member, discardWork) {
+		if (!await pathExists(member.dir)) return null;
+		const reason = discardWork ? null : await findMemberWork(member);
+		if (reason) return {
+			path: member.dir,
+			reason
+		};
+		const removed = await gitWorkspace.removeWorkspaceMember({
+			projectPath: member.repoPath,
+			cwd: member.dir,
+			shareList,
+			discardWork
+		});
+		if (removed.ok) return null;
+		return {
+			path: member.dir,
+			reason: removed.err?.split("\n")[0] || "git refused to remove it"
+		};
+	}
+	async function release({ keepRepoPaths = [], discardWork = false } = {}) {
 		if (activeProvision) await activeProvision;
 		const keptRepoKeys = new Set(keepRepoPaths.map((repoPath) => caseFoldedPathKey(path.resolve(repoPath))));
-		const keptDirs = [];
+		const kept = [];
 		for (const member of plan.members) {
 			if (keptRepoKeys.has(caseFoldedPathKey(member.repoPath))) continue;
-			if (!await fs.promises.stat(member.dir).then(() => true, () => false)) continue;
-			if (!(await gitWorkspace.removeWorkspaceMember({
-				projectPath: member.repoPath,
-				cwd: member.dir,
-				shareList
-			})).ok) keptDirs.push(member.dir);
+			const keptMember = await releaseMember(member, discardWork);
+			if (keptMember) kept.push(keptMember);
 		}
-		const entries = await fs.promises.readdir(plan.folder).catch(() => []);
-		if (entries.some((entry) => !GENERATED_WORKSPACE_FILES.has(entry))) return { keptDirs };
-		for (const entry of entries) await fs.promises.rm(path.join(plan.folder, entry), { force: true });
-		await fs.promises.rmdir(plan.folder).catch(() => {});
-		return { keptDirs };
+		if (keptRepoKeys.size > 0) return { kept };
+		for (const member of plan.members) if (await pathExists(member.dir)) return { kept };
+		await fs.promises.rm(plan.folder, {
+			recursive: true,
+			force: true
+		});
+		await gitWorkspace.forgetRemovedPath(plan.folder);
+		return { kept };
 	}
 	return {
 		provision,
 		release,
+		findKeptWork,
 		branch: plan.branch
 	};
 }
@@ -16711,6 +17519,18 @@ function createSessionWorkspaceMembers({ plan, sessionName, shareList, gitWorksp
 //#region session/session-worktree-lifecycle.ts
 var WORKTREE_CHECK_DEBOUNCE_MS = 400;
 var GIT_NOT_FOUND_EXIT_CODE = 1;
+function workspaceMemberGit(gitWorkspace) {
+	if (!gitWorkspace) return null;
+	const { ensureWorkspaceMember, removeWorkspaceMember, describeWorkspaceMemberWork, recordOwnedFolder, forgetRemovedPath } = gitWorkspace;
+	if (!ensureWorkspaceMember || !removeWorkspaceMember || !describeWorkspaceMemberWork || !recordOwnedFolder || !forgetRemovedPath) return null;
+	return {
+		ensureWorkspaceMember,
+		removeWorkspaceMember,
+		describeWorkspaceMemberWork,
+		recordOwnedFolder,
+		forgetRemovedPath
+	};
+}
 async function readGitStrict(args, options) {
 	const command = await runGit(args, {
 		...options,
@@ -16750,9 +17570,8 @@ function setUpWorkspaceMembers({ folder, sessionId, sessionName, repoPaths, shar
 		repoPaths
 	});
 	if (!planned.ok) return planned;
-	const ensureWorkspaceMember = gitWorkspace?.ensureWorkspaceMember;
-	const removeWorkspaceMember = gitWorkspace?.removeWorkspaceMember;
-	if (!ensureWorkspaceMember || !removeWorkspaceMember) return {
+	const memberGit = workspaceMemberGit(gitWorkspace);
+	if (!memberGit) return {
 		ok: false,
 		error: "Git workspace is unavailable"
 	};
@@ -16760,12 +17579,10 @@ function setUpWorkspaceMembers({ folder, sessionId, sessionName, repoPaths, shar
 		ok: true,
 		members: createSessionWorkspaceMembers({
 			plan: planned.plan,
+			owner: `session:${sessionId}`,
 			sessionName,
 			shareList,
-			gitWorkspace: {
-				ensureWorkspaceMember,
-				removeWorkspaceMember
-			}
+			gitWorkspace: memberGit
 		})
 	};
 }
@@ -17060,6 +17877,7 @@ function createSessionWorktreeLifecycle({ id, projectPath, integrationBranch = n
 		try {
 			workspace = await gitWorkspace.create({
 				projectPath: currentProjectPath(),
+				owner: `session:${id}`,
 				teamId: "session",
 				label: id,
 				baseBranch,
@@ -17162,9 +17980,21 @@ function createSessionWorktreeLifecycle({ id, projectPath, integrationBranch = n
 		lifecycleState.isWorktree = false;
 		setMergeStatus(status);
 	}
+	let isWorkspaceWorkDiscardConfirmed = false;
+	function confirmWorkspaceWorkDiscard() {
+		isWorkspaceWorkDiscardConfirmed = true;
+	}
+	async function findWorkspaceKeptWork() {
+		if (!workspaceMembers?.ok) return [];
+		return workspaceMembers.members.findKeptWork();
+	}
 	async function releaseWorkspaceMembers(members, keepRepoPaths = []) {
-		const released = await members.release({ keepRepoPaths });
-		if (released.keptDirs.length > 0) console.warn(`[session ${id}] kept workspace members with uncommitted work: ${released.keptDirs.join(", ")}`);
+		const released = await members.release({
+			keepRepoPaths,
+			discardWork: isWorkspaceWorkDiscardConfirmed
+		});
+		if (released.kept.length === 0) return;
+		console.warn(`[session ${id}] kept workspace members: ${released.kept.map((kept) => `${kept.path} (${kept.reason})`).join(", ")}`);
 	}
 	async function releaseDroppedWorkspaceMembers(keepRepoPaths) {
 		if (!workspaceMembers?.ok) return;
@@ -17947,6 +18777,8 @@ function createSessionWorktreeLifecycle({ id, projectPath, integrationBranch = n
 		setMergeStatus,
 		pasteMergePrompt,
 		hasUnmergedWork,
+		findWorkspaceKeptWork,
+		confirmWorkspaceWorkDiscard,
 		getDiff,
 		getChangeScopes,
 		resolveEffectiveBase,
@@ -19318,6 +20150,12 @@ var Session = class extends EventEmitter {
 	discardWorktree() {
 		return this.worktreeLifecycle.discardWorktree();
 	}
+	findWorkspaceKeptWork() {
+		return this.worktreeLifecycle.findWorkspaceKeptWork();
+	}
+	confirmWorkspaceWorkDiscard() {
+		this.worktreeLifecycle.confirmWorkspaceWorkDiscard();
+	}
 	getDetectionStats() {
 		return {
 			lastSignal: this._lastSignal,
@@ -20868,760 +21706,200 @@ function boundedToolCallInput(input) {
 		return {
 			input: bounded.text,
 			truncated: true
-		};
-	}
-	if (!input || typeof input !== "object") return { input };
-	const bounded = Array.isArray(input) ? {
-		input,
-		hasCutProperty: false
-	} : boundedInputProperties(input);
-	const serialized = serializedInputText(bounded.input);
-	if (serialized.length > MAX_TRACE_CALL_INPUT_CHARS) return {
-		input: serialized.slice(0, MAX_TRACE_BODY_CHARS),
-		truncated: true
-	};
-	if (!bounded.hasCutProperty) return { input };
-	return {
-		input: bounded.input,
-		truncated: true
-	};
-}
-function everyTextBlockJoined(blocks) {
-	const blockTexts = blocks.flatMap((block) => firstTextBlock([block]) ?? []);
-	if (blockTexts.length === 0) return null;
-	return blockTexts.join("\n");
-}
-function isTaskNotificationLine(line) {
-	return line.origin?.kind === "task-notification" || line.turnOrigin?.kind === "task_notification";
-}
-function mapUserLine(rawLine, line, context) {
-	const base = baseRecord(line, context);
-	const content = line.message?.content;
-	const blocks = contentBlocks(line);
-	const toolResult = blocks.find((block) => block.type === "tool_result");
-	if (toolResult) {
-		const toolUseId = rawTextOr(toolResult.tool_use_id, null);
-		if (!toolUseId) return [rawRecord(rawLine, line, context)];
-		const bounded = boundedText(textContent(toolResult.content));
-		return [{
-			...base,
-			kind: "tool_result",
-			toolUseId,
-			content: bounded.text,
-			isError: toolResult.is_error === true,
-			truncated: bounded.truncated
-		}];
-	}
-	if (line.isMeta === true) {
-		const expansionText = typeof content === "string" ? content : everyTextBlockJoined(blocks);
-		if (!expansionText) return [rawRecord(rawLine, line, context)];
-		const sourceToolUseId = rawTextOr(line.sourceToolUseID, null);
-		if (!sourceToolUseId) return [{
-			...base,
-			kind: "expansion",
-			...boundedTextFields(expansionText)
-		}];
-		return [{
-			...base,
-			kind: "expansion",
-			toolUseId: sourceToolUseId,
-			...boundedTextFields(expansionText)
-		}];
-	}
-	const text = typeof content === "string" ? content : firstTextBlock(blocks);
-	if (!text) return [rawRecord(rawLine, line, context)];
-	if (isTaskNotificationLine(line)) return [{
-		...base,
-		kind: "expansion",
-		...boundedTextFields(text)
-	}];
-	if (typeof content === "string" && /<command-name>[\s\S]*?<\/command-name>/.test(content)) return [{
-		...base,
-		kind: "expansion",
-		...boundedTextFields(content)
-	}];
-	return [{
-		...base,
-		kind: "prompt",
-		...boundedTextFields(text)
-	}];
-}
-function queuedCommandText(prompt) {
-	if (typeof prompt === "string") return prompt || null;
-	return firstTextBlock(objectBlocks(prompt));
-}
-function queuedCommandRecords(line, context) {
-	const attachment = line.attachment;
-	if (line.type !== "attachment" || attachment?.type !== "queued_command") return null;
-	const text = queuedCommandText(attachment.prompt);
-	if (!text) return null;
-	if (attachment.commandMode === "prompt" && attachment.origin?.kind === "human") return [{
-		...baseRecord(line, context),
-		kind: "prompt",
-		...boundedTextFields(text)
-	}];
-	if (attachment.commandMode === "task-notification") return [{
-		...baseRecord(line, context),
-		kind: "expansion",
-		...boundedTextFields(text)
-	}];
-	return null;
-}
-function mapAssistantLine(rawLine, line, context) {
-	const base = baseRecord(line, context);
-	const records = [];
-	let hasSkippedThinkingBlock = false;
-	for (const block of contentBlocks(line)) {
-		if (block.type === "thinking" && typeof block.thinking === "string") {
-			if (block.thinking.length === 0) {
-				hasSkippedThinkingBlock = true;
-				continue;
-			}
-			records.push({
-				...base,
-				kind: "thinking",
-				...boundedTextFields(block.thinking)
-			});
-			continue;
-		}
-		if (block.type === "text") {
-			const text = firstTextBlock([block]);
-			if (text) records.push({
-				...base,
-				kind: "assistant",
-				...boundedTextFields(text)
-			});
-			continue;
-		}
-		if (block.type !== "tool_use") continue;
-		const toolUseId = rawTextOr(block.id, null);
-		const name = rawTextOr(block.name, null);
-		if (!toolUseId || !name) return [rawRecord(rawLine, line, context)];
-		records.push({
-			...base,
-			kind: "tool_call",
-			toolUseId,
-			name,
-			...boundedToolCallInput(block.input)
-		});
-	}
-	if (records.length === 0 && hasSkippedThinkingBlock) return [];
-	if (records.length === 0) return [rawRecord(rawLine, line, context)];
-	return records;
-}
-function traceRecordsFromTranscriptLine(rawLine, context) {
-	const line = parseTranscriptLine(rawLine);
-	if (!line) return [rawRecord(rawLine, null, context)];
-	const queuedRecords = queuedCommandRecords(line, context);
-	if (queuedRecords) return queuedRecords;
-	if (isDroppedLine(line)) return [];
-	if (line.type === "user") return mapUserLine(rawLine, line, context);
-	if (line.type === "assistant") return mapAssistantLine(rawLine, line, context);
-	return [rawRecord(rawLine, line, context)];
-}
-//#endregion
-//#region server/core/investigation-trail-core.ts
-var TRAIL_MAX_STEPS = 80;
-var TRAIL_TOOL_MAX_CHARS = 64;
-var TRAIL_NOTE_MAX_CHARS = 600;
-function describeToolStep(toolName, toolInput) {
-	const trimmed = typeof toolName === "string" ? toolName.trim() : "";
-	if (!trimmed) return null;
-	const tool = trimmed.slice(0, TRAIL_TOOL_MAX_CHARS);
-	return {
-		tool,
-		detail: toolDetailLine(tool, toolInput)
-	};
-}
-function trailStepFromHook(event, payload) {
-	if (String(event ?? "").toLowerCase() !== "pretooluse") return null;
-	return describeToolStep(payload.tool_name, payload.tool_input);
-}
-function trailNotesFromTranscriptLines(lines, now) {
-	return lines.flatMap((line) => traceRecordsFromTranscriptLine(line, {
-		vendorSessionId: "",
-		now
-	})).flatMap((record) => record.kind === "assistant" ? [record.text.trim().slice(0, TRAIL_NOTE_MAX_CHARS)] : []).filter((note) => note !== "");
-}
-function createInvestigationTrail(startedAt) {
-	return {
-		startedAt,
-		steps: []
-	};
-}
-function appendTrailStep(trail, step, maxSteps = TRAIL_MAX_STEPS) {
-	const isAppendingNote = isTrailNote(step);
-	const sameKindEntries = trail.steps.filter((entry) => isTrailNote(entry) === isAppendingNote);
-	const evictedCount = Math.max(0, sameKindEntries.length + 1 - maxSteps);
-	const evictedEntries = new Set(sameKindEntries.slice(0, evictedCount));
-	const keptEntries = trail.steps.filter((entry) => !evictedEntries.has(entry));
-	return {
-		startedAt: trail.startedAt,
-		steps: [...keptEntries, step]
-	};
-}
-function isTrailNote(entry) {
-	return "note" in entry;
-}
-//#endregion
-//#region shared/contracts/guardrails-launch.ts
-var GuardrailsLaunchLogin = z.object({
-	linkPath: z.string().min(1),
-	targetPath: z.string().min(1)
-}).strict();
-var GuardrailsLaunchOwner = z.object({
-	ownerPid: z.number().int().positive(),
-	ownerHost: z.string(),
-	ownerPidNamespace: z.string().nullable(),
-	ownsTempDir: z.boolean(),
-	keptTempFolderName: z.string().min(1).optional(),
-	logins: z.array(GuardrailsLaunchLogin),
-	placeholderPaths: z.array(z.string().min(1))
-}).strict();
-//#endregion
-//#region server/core/claude-trust-core.ts
-var CLAUDE_GLOBAL_CONFIG_FILE_NAME = ".claude.json";
-var CLAUDE_LEGACY_CONFIG_FILE_NAME = ".config.json";
-var CLAUDE_CONFIG_LOCK_SUFFIX = ".lock";
-var CLAUDE_CONFIG_LOCK_STALE_MS = 1e4;
-var CLAUDE_CONFIG_LOCK_RETRY_DELAYS_MS = Object.freeze([
-	200,
-	400,
-	800,
-	1600
-]);
-var GRANTED_KEYS = Object.freeze([
-	"hasTrustDialogAccepted",
-	"hasClaudeMdExternalIncludesApproved",
-	"hasClaudeMdExternalIncludesWarningShown"
-]);
-var TRUST_ONLY_KEYS = Object.freeze(["hasTrustDialogAccepted"]);
-function isPlainRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function newProjectEntry() {
-	return {
-		allowedTools: [],
-		mcpContextUris: [],
-		mcpServers: {},
-		enabledMcpjsonServers: [],
-		disabledMcpjsonServers: []
-	};
-}
-function listClaudeGlobalConfigPathCandidates(env, homeDir) {
-	const configuredDir = env.CLAUDE_CONFIG_DIR?.trim();
-	const legacyConfigHome = (configuredDir || path.join(homeDir, ".claude")).normalize("NFC");
-	return [path.join(legacyConfigHome, CLAUDE_LEGACY_CONFIG_FILE_NAME), path.join(configuredDir || homeDir, CLAUDE_GLOBAL_CONFIG_FILE_NAME)];
-}
-function claudeProjectKeyOf(folderPath, platform) {
-	if (platform !== "win32") return path.posix.normalize(folderPath);
-	return path.win32.normalize(folderPath).replaceAll("\\", "/");
-}
-function repositoryRootOfCommonGitDir(commonGitDir) {
-	if (!path.isAbsolute(commonGitDir) || path.basename(commonGitDir) !== ".git") return null;
-	return path.dirname(commonGitDir);
-}
-function isConfigLockStale(lockModifiedMs, nowMs) {
-	return nowMs - lockModifiedMs > CLAUDE_CONFIG_LOCK_STALE_MS;
-}
-function hasRecordedExternalImportsDecline(existingEntry) {
-	return existingEntry?.hasClaudeMdExternalIncludesWarningShown === true && existingEntry.hasClaudeMdExternalIncludesApproved !== true;
-}
-function decideFolderTrust(configText, repositoryRoot, platform) {
-	const projectKey = claudeProjectKeyOf(repositoryRoot, platform);
-	let config;
-	try {
-		config = JSON.parse(configText);
-	} catch {
-		return {
-			kind: "unreadable",
-			reason: "it is not valid JSON"
-		};
-	}
-	if (!isPlainRecord(config)) return {
-		kind: "unreadable",
-		reason: "it is not a JSON object"
-	};
-	const projects = config.projects ?? {};
-	if (!isPlainRecord(projects)) return {
-		kind: "unreadable",
-		reason: "its projects key is not an object"
-	};
-	const existingEntry = projects[projectKey];
-	if (existingEntry !== void 0 && !isPlainRecord(existingEntry)) return {
-		kind: "unreadable",
-		reason: "its entry for this folder is not an object"
-	};
-	const keysToGrant = hasRecordedExternalImportsDecline(existingEntry) ? TRUST_ONLY_KEYS : GRANTED_KEYS;
-	if (keysToGrant.every((key) => existingEntry?.[key] === true)) return { kind: "trusted" };
-	const trustedEntry = {
-		...existingEntry ?? newProjectEntry(),
-		...Object.fromEntries(keysToGrant.map((key) => [key, true]))
-	};
-	const nextConfigText = JSON.stringify({
-		...config,
-		projects: {
-			...projects,
-			[projectKey]: trustedEntry
-		}
-	}, null, 2);
-	return {
-		kind: "grant",
-		nextConfigText: configText.endsWith("\n") ? `${nextConfigText}\n` : nextConfigText
-	};
-}
-//#endregion
-//#region server/guardrails/core/guardrails-bridge-socket-core.ts
-var LONGEST_BRIDGE_SOCKET_NAME = "claude-socks-0123456789abcdef.sock";
-var UNIX_SOCKET_PATH_BYTE_LIMIT = 107;
-var SHORT_BRIDGE_SOCKET_FOLDER = "/tmp";
-function bridgeSocketPathBytes(tempDirectory) {
-	return Buffer.byteLength(path.join(tempDirectory, LONGEST_BRIDGE_SOCKET_NAME));
-}
-function hasRoomForBridgeSocket(tempDirectory, platform) {
-	return platform !== "linux" || bridgeSocketPathBytes(tempDirectory) <= UNIX_SOCKET_PATH_BYTE_LIMIT;
-}
-function bridgeSocketLauncherEnv(inheritedTempDirectory, platform) {
-	if (hasRoomForBridgeSocket(inheritedTempDirectory, platform)) return { TMPDIR: inheritedTempDirectory };
-	return { TMPDIR: SHORT_BRIDGE_SOCKET_FOLDER };
-}
-//#endregion
-//#region server/prune-files.ts
-var MS_PER_DAY = 864e5;
-function idForEntry(entry, suffixes) {
-	for (const suffix of suffixes) {
-		if (suffix.length === 0) return entry;
-		if (entry.endsWith(suffix)) return entry.slice(0, -suffix.length);
-	}
-	return null;
-}
-async function pruneAgedFiles({ directory, suffixes, retainDays, now = Date.now(), isRetainedId = () => false, entryMode = "file", fsPromises = fs.promises }) {
-	let entries;
-	try {
-		entries = await fsPromises.readdir(directory);
-	} catch {
-		return [];
-	}
-	const cutoff = now - retainDays * MS_PER_DAY;
-	const removedIds = [];
-	for (const entry of entries) {
-		const id = idForEntry(entry, suffixes);
-		if (!id || isRetainedId(id)) continue;
-		const filePath = path.join(directory, entry);
-		try {
-			if ((await fsPromises.stat(filePath)).mtimeMs >= cutoff) continue;
-			if (entryMode === "directory") await fsPromises.rm(filePath, {
-				recursive: true,
-				force: true
-			});
-			if (entryMode === "file") await fsPromises.unlink(filePath);
-			removedIds.push(id);
-		} catch {}
-	}
-	return removedIds;
-}
-//#endregion
-//#region server/guardrails/guardrails-launch.ts
-var LAUNCH_ID_SHAPE = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
-var GUARDED_ENV_COMMAND = "/usr/bin/env";
-var POLICY_FOLDER = "guardrails-policies";
-var LAUNCH_HOME_FOLDER = "guardrails-homes";
-var START_FOLDER = "start";
-var OWNER_FILE_SUFFIX = ".owner.json";
-var ENTER_FOLDER_SCRIPT = "cd \"$1\" && shift && exec \"$@\"";
-var LOGIN_FILE_MODE = 384;
-var ABSENT_PATH_DENY_PLATFORM = "darwin";
-var OWN_PID_NAMESPACE_LINK = "/proc/self/ns/pid";
-var SESSION_TEMP_RETAIN_DAYS = 7;
-async function isPresent(candidate) {
-	try {
-		await access(candidate);
-		return true;
-	} catch (error) {
-		if (!isMissingFileError(error)) throw error;
-		return false;
-	}
-}
-async function presentPaths$1(candidates) {
-	const presence = await Promise.all(candidates.map(isPresent));
-	return new Set(candidates.filter((_candidate, index) => presence[index]));
-}
-async function realPathWhenPresent(candidate) {
-	if (!path.isAbsolute(candidate)) return candidate;
-	try {
-		return await realpath(candidate);
-	} catch (error) {
-		if (!isMissingFileError(error)) throw error;
-		return candidate;
-	}
-}
-function realPathsWhenPresent(candidates) {
-	return Promise.all(candidates.map(realPathWhenPresent));
-}
-async function symlinkTargetsInside(folder) {
-	const symlinkEntries = (await readdir(folder, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isSymbolicLink());
-	return (await Promise.all(symlinkEntries.map((entry) => realpath(path.join(folder, entry.name)).catch(() => null)))).filter((target) => target !== null);
-}
-async function blockedPathsWithRealTargets(candidates, operatorBlockedPaths) {
-	const resolved = await Promise.all(candidates.map(async (candidate) => {
-		const isPresentEntry = await lstat(candidate).then(() => true, (error) => !isMissingFileError(error));
-		const isKeptWhenAbsent = process.platform === ABSENT_PATH_DENY_PLATFORM || operatorBlockedPaths.includes(candidate);
-		if (!isPresentEntry) return isKeptWhenAbsent ? [candidate] : [];
-		const realCandidate = await realpath(candidate).catch(() => candidate);
-		return [
-			candidate,
-			realCandidate,
-			...await symlinkTargetsInside(realCandidate)
-		];
-	}));
-	return [...new Set(resolved.flat())];
-}
-async function configuredConfigFile(glimmervoidHome) {
-	const { envPath, homePath } = decideConfigPath({
-		env: process.env,
-		homeDir: glimmervoidHome
-	}, () => false);
-	const configFile = envPath ?? homePath;
-	return path.join(await realPathWhenPresent(path.dirname(configFile)), path.basename(configFile));
-}
-function scannedClaudeHomes(env, homeDir) {
-	return [env, {
-		...env,
-		CLAUDE_CONFIG_DIR: void 0
-	}].flatMap((scannedEnv) => projectDirCandidates(scannedEnv, [], homeDir)).map((projectsDir) => path.dirname(projectsDir));
-}
-async function resolveVendorLocations(env, homeDir) {
-	const [legacyClaudeConfigPath, claudeConfigPath] = listClaudeGlobalConfigPathCandidates(env, homeDir);
-	const [codexStateFolder, ...otherCodexHomes] = codexHomes(env, homeDir);
-	if (codexStateFolder === void 0) return null;
-	return {
-		claude: {
-			stateFolder: await realPathWhenPresent(path.dirname(legacyClaudeConfigPath)),
-			configFiles: [await realPathWhenPresent(claudeConfigPath)],
-			otherHomes: await realPathsWhenPresent(scannedClaudeHomes(env, homeDir))
-		},
-		codex: {
-			stateFolder: await realPathWhenPresent(codexStateFolder),
-			configFiles: [],
-			otherHomes: await realPathsWhenPresent(otherCodexHomes)
-		}
-	};
-}
-async function withRealRoots(role) {
-	const [writableRoots, lockedCheckouts, commitCheckouts] = await Promise.all([
-		Promise.all(role.writableRoots.map((root) => realpath(root))),
-		Promise.all(role.lockedCheckouts.map((checkout) => realpath(checkout))),
-		Promise.all(role.commitCheckouts.map(async ({ checkout, gitDir }) => ({
-			checkout: await realpath(checkout),
-			gitDir: await realpath(gitDir)
-		})))
-	]);
-	const vendorHome = role.vendorHome.scope === "launch" ? {
-		...role.vendorHome,
-		cwd: await realPathWhenPresent(role.vendorHome.cwd)
-	} : role.vendorHome;
-	return {
-		...role,
-		vendorHome,
-		writableRoots,
-		lockedCheckouts,
-		commitCheckouts,
-		readableWithinDenied: await realPathsWhenPresent(role.readableWithinDenied)
-	};
-}
-async function lstatWhenPresent(candidate) {
-	try {
-		return await lstat(candidate);
-	} catch (error) {
-		if (!isMissingFileError(error)) throw error;
-		return null;
-	}
-}
-async function isRegularFile(candidate) {
-	return (await lstatWhenPresent(candidate))?.isFile() ?? false;
-}
-async function isRealDirectory$1(candidate) {
-	return (await lstatWhenPresent(candidate))?.isDirectory() ?? false;
-}
-async function absentPaths(candidates) {
-	const presentCandidates = await presentPaths$1(candidates);
-	return candidates.filter((candidate) => !presentCandidates.has(candidate));
-}
-async function removeLeftoverPlaceholders(placeholderPaths) {
-	for (const placeholderPath of placeholderPaths) {
-		const placeholderStats = await lstat(placeholderPath).catch(() => null);
-		if (placeholderStats?.isFile() && placeholderStats.size === 0) await rm(placeholderPath, { force: true });
+		};
 	}
+	if (!input || typeof input !== "object") return { input };
+	const bounded = Array.isArray(input) ? {
+		input,
+		hasCutProperty: false
+	} : boundedInputProperties(input);
+	const serialized = serializedInputText(bounded.input);
+	if (serialized.length > MAX_TRACE_CALL_INPUT_CHARS) return {
+		input: serialized.slice(0, MAX_TRACE_BODY_CHARS),
+		truncated: true
+	};
+	if (!bounded.hasCutProperty) return { input };
+	return {
+		input: bounded.input,
+		truncated: true
+	};
 }
-async function createMissingMountPoints(mountPoints) {
-	for (const mountPoint of mountPoints) {
-		if (!await isRealDirectory$1(path.dirname(mountPoint))) continue;
-		await mkdir(mountPoint).catch((error) => {
-			if (errorCode(error) !== "EEXIST") throw error;
-		});
-	}
+function everyTextBlockJoined(blocks) {
+	const blockTexts = blocks.flatMap((block) => firstTextBlock([block]) ?? []);
+	if (blockTexts.length === 0) return null;
+	return blockTexts.join("\n");
 }
-async function isNewerThanTarget(linkPath, targetPath) {
-	const targetStats = await stat(targetPath).catch(() => null);
-	if (targetStats === null) return true;
-	return (await lstat(linkPath)).mtimeMs > targetStats.mtimeMs;
+function isTaskNotificationLine(line) {
+	return line.origin?.kind === "task-notification" || line.turnOrigin?.kind === "task_notification";
 }
-async function keepRefreshedLogins(logins, launchId, { onlyWhenNewer }) {
-	for (const { linkPath, targetPath } of logins) {
-		if (!await isRegularFile(linkPath)) continue;
-		if (onlyWhenNewer && !await isNewerThanTarget(linkPath, targetPath)) continue;
-		const stagedPath = `${targetPath}.${launchId}`;
-		await copyFile(linkPath, stagedPath);
-		await chmod(stagedPath, LOGIN_FILE_MODE);
-		await rename(stagedPath, targetPath);
+function mapUserLine(rawLine, line, context) {
+	const base = baseRecord(line, context);
+	const content = line.message?.content;
+	const blocks = contentBlocks(line);
+	const toolResult = blocks.find((block) => block.type === "tool_result");
+	if (toolResult) {
+		const toolUseId = rawTextOr(toolResult.tool_use_id, null);
+		if (!toolUseId) return [rawRecord(rawLine, line, context)];
+		const bounded = boundedText(textContent(toolResult.content));
+		return [{
+			...base,
+			kind: "tool_result",
+			toolUseId,
+			content: bounded.text,
+			isError: toolResult.is_error === true,
+			truncated: bounded.truncated
+		}];
 	}
-}
-async function removeLaunch(folders, owner, launchId, { onlyNewerLogins }) {
-	await rm(folders.policyPath, { force: true });
-	await removeLeftoverPlaceholders(owner.placeholderPaths);
-	await keepRefreshedLogins(owner.logins.filter((login) => isPathInside(folders.launchHomeDir, login.linkPath, { allowEqual: false })), launchId, { onlyWhenNewer: onlyNewerLogins });
-	await rm(folders.launchHomeDir, {
-		recursive: true,
-		force: true
-	});
-	if (folders.ownedTempDir !== null) await rm(folders.ownedTempDir, {
-		recursive: true,
-		force: true
-	});
-	await rm(folders.ownerPath, { force: true });
-}
-function isProcessAlive$1(pid) {
-	try {
-		process.kill(pid, 0);
-		return true;
-	} catch (error) {
-		return errorCode(error) === "EPERM";
+	if (line.isMeta === true) {
+		const expansionText = typeof content === "string" ? content : everyTextBlockJoined(blocks);
+		if (!expansionText) return [rawRecord(rawLine, line, context)];
+		const sourceToolUseId = rawTextOr(line.sourceToolUseID, null);
+		if (!sourceToolUseId) return [{
+			...base,
+			kind: "expansion",
+			...boundedTextFields(expansionText)
+		}];
+		return [{
+			...base,
+			kind: "expansion",
+			toolUseId: sourceToolUseId,
+			...boundedTextFields(expansionText)
+		}];
 	}
+	const text = typeof content === "string" ? content : firstTextBlock(blocks);
+	if (!text) return [rawRecord(rawLine, line, context)];
+	if (isTaskNotificationLine(line)) return [{
+		...base,
+		kind: "expansion",
+		...boundedTextFields(text)
+	}];
+	if (typeof content === "string" && /<command-name>[\s\S]*?<\/command-name>/.test(content)) return [{
+		...base,
+		kind: "expansion",
+		...boundedTextFields(content)
+	}];
+	return [{
+		...base,
+		kind: "prompt",
+		...boundedTextFields(text)
+	}];
 }
-function readOwnPidNamespace() {
-	return readlink(OWN_PID_NAMESPACE_LINK).catch(() => null);
+function queuedCommandText(prompt) {
+	if (typeof prompt === "string") return prompt || null;
+	return firstTextBlock(objectBlocks(prompt));
 }
-async function readOwnerFile(ownerPath) {
-	const outcome = await loadJsonStateFile({
-		filePath: ownerPath,
-		quarantine: false,
-		parse: (raw) => GuardrailsLaunchOwner.safeParse(raw).data ?? null
-	});
-	return outcome.status === "loaded" ? outcome.value : null;
+function queuedCommandRecords(line, context) {
+	const attachment = line.attachment;
+	if (line.type !== "attachment" || attachment?.type !== "queued_command") return null;
+	const text = queuedCommandText(attachment.prompt);
+	if (!text) return null;
+	if (attachment.commandMode === "prompt" && attachment.origin?.kind === "human") return [{
+		...baseRecord(line, context),
+		kind: "prompt",
+		...boundedTextFields(text)
+	}];
+	if (attachment.commandMode === "task-notification") return [{
+		...baseRecord(line, context),
+		kind: "expansion",
+		...boundedTextFields(text)
+	}];
+	return null;
 }
-async function sweepOrphanedGuardrailsLaunches(log = console) {
-	try {
-		const policyDir = path.join(glimmervoidHomeDir$1(), POLICY_FOLDER);
-		const entryNames = await readdir(policyDir).catch((error) => {
-			if (isMissingFileError(error)) return [];
-			throw error;
-		});
-		const glimmervoidHome = await realpath(glimmervoidHomeDir$1());
-		const sweeperPidNamespace = await readOwnPidNamespace();
-		let removedLaunchCount = 0;
-		for (const entryName of entryNames) {
-			if (!entryName.endsWith(OWNER_FILE_SUFFIX)) continue;
-			const launchId = entryName.slice(0, -11);
-			if (!LAUNCH_ID_SHAPE.test(launchId)) continue;
-			const ownerPath = path.join(policyDir, entryName);
-			const owner = await readOwnerFile(ownerPath);
-			if (owner === null || owner.ownerHost !== os.hostname() || owner.ownerPidNamespace !== sweeperPidNamespace || isProcessAlive$1(owner.ownerPid)) continue;
-			try {
-				await removeLaunch({
-					policyPath: path.join(policyDir, `${launchId}.json`),
-					ownerPath,
-					launchHomeDir: path.join(glimmervoidHome, LAUNCH_HOME_FOLDER, launchId),
-					ownedTempDir: owner.ownsTempDir ? path.join(glimmervoidHome, GUARDRAILS_TEMP_FOLDER, launchId) : null
-				}, owner, launchId, { onlyNewerLogins: true });
-				removedLaunchCount += 1;
-			} catch (error) {
-				log.warn(`[guardrails] could not remove the leftover launch ${launchId}: ${errorMessage(error)}`);
+function mapAssistantLine(rawLine, line, context) {
+	const base = baseRecord(line, context);
+	const records = [];
+	let hasSkippedThinkingBlock = false;
+	for (const block of contentBlocks(line)) {
+		if (block.type === "thinking" && typeof block.thinking === "string") {
+			if (block.thinking.length === 0) {
+				hasSkippedThinkingBlock = true;
+				continue;
 			}
+			records.push({
+				...base,
+				kind: "thinking",
+				...boundedTextFields(block.thinking)
+			});
+			continue;
 		}
-		if (removedLaunchCount > 0) log.log(`[guardrails] removed ${removedLaunchCount} launch folders left by sessions that ended without a clean shutdown`);
-	} catch (error) {
-		log.warn(`[guardrails] could not sweep leftover launch folders: ${errorMessage(error)}`);
+		if (block.type === "text") {
+			const text = firstTextBlock([block]);
+			if (text) records.push({
+				...base,
+				kind: "assistant",
+				...boundedTextFields(text)
+			});
+			continue;
+		}
+		if (block.type !== "tool_use") continue;
+		const toolUseId = rawTextOr(block.id, null);
+		const name = rawTextOr(block.name, null);
+		if (!toolUseId || !name) return [rawRecord(rawLine, line, context)];
+		records.push({
+			...base,
+			kind: "tool_call",
+			toolUseId,
+			name,
+			...boundedToolCallInput(block.input)
+		});
 	}
+	if (records.length === 0 && hasSkippedThinkingBlock) return [];
+	if (records.length === 0) return [rawRecord(rawLine, line, context)];
+	return records;
 }
-async function pruneLeftoverSessionTempFolders(glimmervoidHome, liveSessionIds, log = console) {
-	const policyEntryNames = await readdir(path.join(glimmervoidHome, POLICY_FOLDER)).catch((error) => {
-		if (isMissingFileError(error)) return [];
-		log.warn(`[guardrails] kept every session temp folder because the launch list could not be read: ${errorMessage(error)}`);
-		return null;
-	});
-	if (policyEntryNames === null) return;
-	const ownerEntryNames = policyEntryNames.filter((entryName) => entryName.endsWith(OWNER_FILE_SUFFIX));
-	const owners = await Promise.all(ownerEntryNames.map((entryName) => readOwnerFile(path.join(glimmervoidHome, POLICY_FOLDER, entryName))));
-	const tempFolderNamesWithOwners = /* @__PURE__ */ new Set([...ownerEntryNames.map((entryName) => entryName.slice(0, -11)), ...owners.flatMap((owner) => owner?.keptTempFolderName === void 0 ? [] : [owner.keptTempFolderName])]);
-	await pruneAgedFiles({
-		directory: path.join(glimmervoidHome, GUARDRAILS_TEMP_FOLDER),
-		suffixes: [""],
-		retainDays: SESSION_TEMP_RETAIN_DAYS,
-		entryMode: "directory",
-		isRetainedId: (id) => liveSessionIds.has(id) || tempFolderNamesWithOwners.has(id)
-	});
+function traceRecordsFromTranscriptLine(rawLine, context) {
+	const line = parseTranscriptLine(rawLine);
+	if (!line) return [rawRecord(rawLine, null, context)];
+	const queuedRecords = queuedCommandRecords(line, context);
+	if (queuedRecords) return queuedRecords;
+	if (isDroppedLine(line)) return [];
+	if (line.type === "user") return mapUserLine(rawLine, line, context);
+	if (line.type === "assistant") return mapAssistantLine(rawLine, line, context);
+	return [rawRecord(rawLine, line, context)];
 }
-function launcherCommand(plan, policyPath) {
-	if (plan.launcher === "open-network") return {
-		file: process.execPath,
-		args: [relayPath("guardrails-open-launcher"), policyPath]
-	};
-	const runtimeCliPath = resolvePackageBin("@anthropic-ai/sandbox-runtime", "srt");
-	if (!runtimeCliPath) return null;
+//#endregion
+//#region server/core/investigation-trail-core.ts
+var TRAIL_MAX_STEPS = 80;
+var TRAIL_TOOL_MAX_CHARS = 64;
+var TRAIL_NOTE_MAX_CHARS = 600;
+function describeToolStep(toolName, toolInput) {
+	const trimmed = typeof toolName === "string" ? toolName.trim() : "";
+	if (!trimmed) return null;
+	const tool = trimmed.slice(0, TRAIL_TOOL_MAX_CHARS);
 	return {
-		file: process.execPath,
-		args: [
-			runtimeCliPath,
-			"--settings",
-			policyPath,
-			"--"
-		]
+		tool,
+		detail: toolDetailLine(tool, toolInput)
 	};
 }
-function guardedEnvPrefix(plan) {
-	const assignments = Object.entries(plan.guardedEnv).map(([name, value]) => `${name}=${value}`);
-	return assignments.length === 0 ? [] : [GUARDED_ENV_COMMAND, ...assignments];
-}
-function enteringFolder(enterDir, file, args) {
-	if (enterDir === void 0) return [file, ...args];
-	return [
-		"/bin/sh",
-		"-c",
-		ENTER_FOLDER_SCRIPT,
-		"sh",
-		enterDir,
-		file,
-		...args
-	];
+function trailStepFromHook(event, payload) {
+	if (String(event ?? "").toLowerCase() !== "pretooluse") return null;
+	return describeToolStep(payload.tool_name, payload.tool_input);
 }
-function launchTempDirFor(glimmervoidHome, launchId, tempDir, keptTempFolderName) {
-	if (tempDir !== void 0) return path.resolve(tempDir);
-	return path.join(glimmervoidHome, GUARDRAILS_TEMP_FOLDER, keptTempFolderName ?? launchId);
+function trailNotesFromTranscriptLines(lines, now) {
+	return lines.flatMap((line) => traceRecordsFromTranscriptLine(line, {
+		vendorSessionId: "",
+		now
+	})).flatMap((record) => record.kind === "assistant" ? [record.text.trim().slice(0, TRAIL_NOTE_MAX_CHARS)] : []).filter((note) => note !== "");
 }
-async function prepareGuardrailsLaunch({ role, launchId, tempDir, keptTempFolderName, enterDir }) {
-	if (!LAUNCH_ID_SHAPE.test(launchId)) return {
-		ok: false,
-		reason: "guardrails launch id is invalid"
+function createInvestigationTrail(startedAt) {
+	return {
+		startedAt,
+		steps: []
 	};
-	if (keptTempFolderName !== void 0 && !LAUNCH_ID_SHAPE.test(keptTempFolderName)) return {
-		ok: false,
-		reason: "guardrails temp folder name is invalid"
+}
+function appendTrailStep(trail, step, maxSteps = TRAIL_MAX_STEPS) {
+	const isAppendingNote = isTrailNote(step);
+	const sameKindEntries = trail.steps.filter((entry) => isTrailNote(entry) === isAppendingNote);
+	const evictedCount = Math.max(0, sameKindEntries.length + 1 - maxSteps);
+	const evictedEntries = new Set(sameKindEntries.slice(0, evictedCount));
+	const keptEntries = trail.steps.filter((entry) => !evictedEntries.has(entry));
+	return {
+		startedAt: trail.startedAt,
+		steps: [...keptEntries, step]
 	};
-	try {
-		const policyDir = path.join(glimmervoidHomeDir$1(), POLICY_FOLDER);
-		await mkdir(policyDir, {
-			recursive: true,
-			mode: 448
-		});
-		const [homeDir, glimmervoidHome, realRole, ownerPidNamespace] = await Promise.all([
-			realpath(os.homedir()),
-			realpath(glimmervoidHomeDir$1()),
-			withRealRoots(role),
-			readOwnPidNamespace()
-		]);
-		const ownsTempDir = tempDir === void 0 && keptTempFolderName === void 0;
-		const launchTempDir = launchTempDirFor(glimmervoidHome, launchId, tempDir, keptTempFolderName);
-		const launchHomeDir = path.join(glimmervoidHome, LAUNCH_HOME_FOLDER, launchId);
-		const vendorLocations = await resolveVendorLocations(process.env, homeDir);
-		if (vendorLocations === null) return {
-			ok: false,
-			reason: "CODEX_HOME names no folder"
-		};
-		const xdgConfigHomeOverride = rawTextOr(process.env.XDG_CONFIG_HOME, null);
-		const stableHostPaths = {
-			homeDir,
-			glimmervoidHome,
-			glimmervoidConfigFile: await configuredConfigFile(glimmervoidHome),
-			tempDir: launchTempDir,
-			launchHomeDir,
-			vendorLocations,
-			unwrappedVendorHomes: await realPathsWhenPresent(grokHomes(process.env, homeDir)),
-			relocatedXdgConfigHome: xdgConfigHomeOverride === null ? null : await realPathWhenPresent(xdgConfigHomeOverride)
-		};
-		const buildPlanFromCurrentDisk = async () => {
-			const [homeEntryNames, glimmervoidHomeEntryNames] = await Promise.all([readdir(homeDir), readdir(glimmervoidHome)]);
-			const hostPaths = {
-				...stableHostPaths,
-				homeEntryNames,
-				glimmervoidHomeEntryNames
-			};
-			const [existingPaths, writeBlockedPaths] = await Promise.all([presentPaths$1(guardrailsPolicyProbePaths(realRole, hostPaths)), blockedPathsWithRealTargets(standardWriteBlockCandidates(realRole, hostPaths), realRole.blockedPaths ?? [])]);
-			return buildGuardrailsLaunchPlan(realRole, {
-				...hostPaths,
-				existingPaths,
-				writeBlockedPaths
-			});
-		};
-		const built = await buildPlanFromCurrentDisk();
-		if (!built.ok) return built;
-		const { plan } = built;
-		const policyPath = path.join(policyDir, `${launchId}.json`);
-		const launcher = launcherCommand(plan, policyPath);
-		if (!launcher) return {
-			ok: false,
-			reason: "the sandbox runtime CLI could not be resolved"
-		};
-		await Promise.all(plan.requiredDirectories.map((directory) => mkdir(directory, { recursive: true })));
-		const startDir = enterDir === void 0 ? void 0 : path.join(launchTempDir, START_FOLDER);
-		if (startDir !== void 0) await mkdir(startDir, { recursive: true });
-		await Promise.all(plan.launchHomeLinks.map((link) => symlink(link.targetPath, link.linkPath)));
-		await writeJsonAtomic(policyPath, plan.policy);
-		const folders = {
-			policyPath,
-			ownerPath: path.join(policyDir, `${launchId}${OWNER_FILE_SUFFIX}`),
-			launchHomeDir,
-			ownedTempDir: ownsTempDir ? launchTempDir : null
-		};
-		const owner = {
-			ownerPid: process.pid,
-			ownerHost: os.hostname(),
-			ownerPidNamespace,
-			ownsTempDir,
-			...keptTempFolderName === void 0 ? {} : { keptTempFolderName },
-			logins: plan.launchHomeLinks.filter((link) => link.isLogin).map(({ linkPath, targetPath }) => ({
-				linkPath,
-				targetPath
-			})),
-			placeholderPaths: []
-		};
-		await writeJsonAtomic(folders.ownerPath, owner);
-		const envPrefix = guardedEnvPrefix(plan);
-		return {
-			ok: true,
-			launch: {
-				wrap: async (file, args, { hasTerminal }) => {
-					const rebuilt = await buildPlanFromCurrentDisk();
-					if (!rebuilt.ok) throw new Error(rebuilt.reason);
-					await writeJsonAtomic(policyPath, {
-						...rebuilt.plan.policy,
-						allowPty: hasTerminal && rebuilt.plan.launcher === "open-network"
-					});
-					owner.placeholderPaths = await absentPaths(guardrailsPlaceholderPaths(realRole));
-					await writeJsonAtomic(folders.ownerPath, owner);
-					await createMissingMountPoints(lockedClaudeMountPoints(realRole));
-					return {
-						file: launcher.file,
-						args: [
-							...launcher.args,
-							...envPrefix,
-							...enteringFolder(enterDir, file, args)
-						]
-					};
-				},
-				env: {
-					...plan.launchEnv,
-					...bridgeSocketLauncherEnv(os.tmpdir(), process.platform)
-				},
-				...startDir === void 0 ? {} : { cwd: startDir },
-				dispose: () => removeLaunch(folders, owner, launchId, { onlyNewerLogins: false })
-			}
-		};
-	} catch (error) {
-		return {
-			ok: false,
-			reason: errorMessage(error)
-		};
-	}
+}
+function isTrailNote(entry) {
+	return "note" in entry;
 }
 //#endregion
 //#region server/lanes/lane-spawn.ts
@@ -21642,7 +21920,7 @@ var LANE_SPAWN_DENY_TOOLS = Object.freeze([
 async function writeStandaloneDenySettings(permissions, userHooks) {
 	const settingsDirectory = await makeHostScratchDirectory(SETTINGS_DIR_PREFIX);
 	const settingsPath = path.join(settingsDirectory, "settings.json");
-	const removeSettingsDirectory = () => fsp.rm(settingsDirectory, {
+	const removeSettingsDirectory = () => fs$1.rm(settingsDirectory, {
 		recursive: true,
 		force: true
 	}).catch(() => {});
@@ -21742,7 +22020,7 @@ function createLaneSpawn({ sessions = /* @__PURE__ */ new Map(), closeSessionDat
 }
 async function readLaneResultFile(resultPath) {
 	try {
-		return JSON.parse(await fsp.readFile(resultPath, "utf8"));
+		return JSON.parse(await fs$1.readFile(resultPath, "utf8"));
 	} catch {
 		return null;
 	}
@@ -21753,12 +22031,12 @@ var THREAD_JUDGE_TOOLS = Object.freeze(["Read", "Write"]);
 var THREAD_JUDGE_TIMEOUT_MS = 12e4;
 function createThreadJudge(spawn, shutdownSignal) {
 	return async (prompt) => {
-		const workDir = await fsp.mkdtemp(path.join(os.tmpdir(), "glimmervoid-thread-judge-"));
+		const workDir = await fs$1.mkdtemp(path.join(os.tmpdir(), "glimmervoid-thread-judge-"));
 		const controller = new AbortController();
 		const timeout = setTimeout(() => controller.abort(), THREAD_JUDGE_TIMEOUT_MS);
 		timeout.unref();
 		try {
-			await fsp.writeFile(path.join(workDir, "thread-prompt.txt"), prompt, "utf8");
+			await fs$1.writeFile(path.join(workDir, "thread-prompt.txt"), prompt, "utf8");
 			const signal = shutdownSignal ? AbortSignal.any([controller.signal, shutdownSignal]) : controller.signal;
 			if (signal.aborted) return null;
 			await spawn({
@@ -21773,7 +22051,7 @@ function createThreadJudge(spawn, shutdownSignal) {
 			return parseThreadJudgeResult(await readLaneResultFile(path.join(workDir, "thread-result.json")));
 		} finally {
 			clearTimeout(timeout);
-			await fsp.rm(workDir, {
+			await fs$1.rm(workDir, {
 				recursive: true,
 				force: true
 			});
@@ -21790,13 +22068,14 @@ var GH_MERGE_FLAGS = {
 var MY_PR_MERGE_STATE_QUERY = `query($owner: String!, $name: String!, $number: Int!) {
   repository(owner: $owner, name: $name) { pullRequest(number: $number) { state isInMergeQueue autoMergeRequest { enabledAt } } }
 }`;
-var GH_TIMEOUT_MS = 3e4;
+var GH_READ_TIMEOUT_MS = 15e3;
+var GH_WRITE_TIMEOUT_MS = 3e4;
 var GH_MAX_BUFFER_BYTES = 2097153;
-function run(cmd, args, cwd, input, preserveOutput = false) {
+function run(cmd, args, cwd, input, preserveOutput = false, timeoutMs = GH_READ_TIMEOUT_MS) {
 	return runCommand(cmd, args, {
 		cwd,
 		input,
-		timeoutMs: GH_TIMEOUT_MS,
+		timeoutMs,
 		maxBuffer: GH_MAX_BUFFER_BYTES,
 		trim: !preserveOutput,
 		keepStdoutOnFailure: true,
@@ -22101,9 +22380,9 @@ function conditionalGetResult(response) {
 	}
 }
 function createPrGh(cwd, commandRunner = run) {
-	async function runGh(args, input, preserveOutput = false) {
+	async function runGh(args, input, preserveOutput = false, timeoutMs = GH_READ_TIMEOUT_MS) {
 		try {
-			return await commandRunner("gh", args, cwd, input, preserveOutput);
+			return await commandRunner("gh", args, cwd, input, preserveOutput, timeoutMs);
 		} catch (error) {
 			return {
 				ok: false,
@@ -22433,7 +22712,7 @@ function createPrGh(cwd, commandRunner = run) {
 				repo,
 				"--add-label",
 				label.data
-			]);
+			], void 0, false, GH_WRITE_TIMEOUT_MS);
 			return {
 				ok: response.ok,
 				err: response.ok ? "" : response.err.trim() || "gh pr edit failed"
@@ -22457,7 +22736,7 @@ function createPrGh(cwd, commandRunner = run) {
 				repo,
 				"--body-file",
 				"-"
-			], comment.data);
+			], comment.data, false, GH_WRITE_TIMEOUT_MS);
 			return {
 				ok: response.ok,
 				err: response.ok ? "" : response.err.trim() || "gh pr comment failed"
@@ -22530,7 +22809,7 @@ function createPrGh(cwd, commandRunner = run) {
 				`query=${RESOLVE_THREAD_MUTATION}`,
 				"-f",
 				`id=${threadId}`
-			]);
+			], void 0, false, GH_WRITE_TIMEOUT_MS);
 			const parsed = TeamReviewResolveResponse.safeParse(parseJsonOrNull(response.out));
 			const isResolved = response.ok && parsed.success && !parsed.data.errors?.length && parsed.data.data?.resolveReviewThread.thread.id === threadId;
 			return {
@@ -22691,7 +22970,7 @@ function createPrGh(cwd, commandRunner = run) {
 				`id=${pullRequestId}`,
 				"-f",
 				`head=${expectedHeadSha}`
-			]);
+			], void 0, false, GH_WRITE_TIMEOUT_MS);
 			if (!response.ok) return {
 				ok: false,
 				err: response.err.trim() || "gh graphql rebase failed"
@@ -22730,7 +23009,7 @@ function createPrGh(cwd, commandRunner = run) {
 				GH_MERGE_FLAGS[parsedMethod.data],
 				"--match-head-commit",
 				headSha
-			]);
+			], void 0, false, GH_WRITE_TIMEOUT_MS);
 			if (!response.ok) return {
 				ok: false,
 				err: response.err.trim() || "gh pr merge failed"
@@ -22966,7 +23245,7 @@ function createPrGh(cwd, commandRunner = run) {
 				`repos/${parts[0]}/${parts[1]}/pulls/${number}/reviews`,
 				"--input",
 				"-"
-			], input);
+			], input, false, GH_WRITE_TIMEOUT_MS);
 			if (!response.ok) return {
 				ok: false,
 				err: response.err.trim() || "gh review post failed",
@@ -23004,7 +23283,7 @@ function createPrGh(cwd, commandRunner = run) {
 				`repos/${parts[0]}/${parts[1]}/pulls/${number}/reviews/${reviewId}/dismissals`,
 				"--input",
 				"-"
-			], input);
+			], input, false, GH_WRITE_TIMEOUT_MS);
 			return {
 				ok: response.ok,
 				err: response.ok ? "" : response.err.trim() || "gh review dismissal failed"
@@ -23358,7 +23637,7 @@ var PROCESS_LIST_TIMEOUT_MS = 5e3;
 var TERMINATION_GRACE_MS = 2e3;
 var EXIT_POLL_MS = 100;
 async function resolvedPath(directory) {
-	return fsp.realpath(directory).catch(() => path.resolve(directory));
+	return fs$1.realpath(directory).catch(() => path.resolve(directory));
 }
 async function listTeamReviewProcesses() {
 	if (process.platform !== "darwin" && process.platform !== "linux") return [];
@@ -23375,7 +23654,7 @@ async function listTeamReviewProcesses() {
 	const rows = parseProcessTable(stdout);
 	if (process.platform === "linux") return Promise.all(rows.map(async (row) => ({
 		...row,
-		cwd: await fsp.readlink(`/proc/${row.pid}/cwd`).then((cwd) => path.resolve(cwd)).catch(() => null)
+		cwd: await fs$1.readlink(`/proc/${row.pid}/cwd`).then((cwd) => path.resolve(cwd)).catch(() => null)
 	})));
 	const { stdout: cwdOutput } = await execFileAsync("lsof", [
 		"-a",
@@ -23390,7 +23669,7 @@ async function listTeamReviewProcesses() {
 	const cwdByPid = parseCwdTable(cwdOutput);
 	return Promise.all(rows.map(async (row) => ({
 		...row,
-		cwd: await fsp.realpath(cwdByPid.get(row.pid) ?? "").catch(() => null)
+		cwd: await fs$1.realpath(cwdByPid.get(row.pid) ?? "").catch(() => null)
 	})));
 }
 function isMissingProcess(error) {
@@ -24137,9 +24416,13 @@ function createTeamReviewPoller(deps) {
 	}
 	async function rateLimitedOutcome() {
 		const rateLimitWaitMs = await store.rateLimitWaitMs(now(), TEAM_REVIEW_RATE_LIMIT_RESOURCES) ?? secondaryRateLimitWaitMs(pollingError);
-		return rateLimitWaitMs === null ? { failed: true } : {
+		return rateLimitWaitMs === null ? {
 			failed: true,
-			retryAfterMs: rateLimitWaitMs
+			error: pollingError ?? void 0
+		} : {
+			failed: true,
+			retryAfterMs: rateLimitWaitMs,
+			error: pollingError ?? void 0
 		};
 	}
 	async function runTick() {
@@ -24154,7 +24437,8 @@ function createTeamReviewPoller(deps) {
 			pollingError = "GitHub rate limit asks to wait.";
 			return {
 				failed: true,
-				retryAfterMs: tickRateLimitWaitMs
+				retryAfterMs: tickRateLimitWaitMs,
+				error: pollingError
 			};
 		}
 		if (collected === null) {
@@ -24172,7 +24456,8 @@ function createTeamReviewPoller(deps) {
 			pollingError = "GitHub rate limit asks to wait.";
 			return {
 				failed: true,
-				retryAfterMs: rateLimitWaitMs
+				retryAfterMs: rateLimitWaitMs,
+				error: pollingError
 			};
 		}
 		const isPruned = await pruneDeparted(new Set(candidates.map((candidate) => candidate.key)), isComplete);
@@ -24185,7 +24470,8 @@ function createTeamReviewPoller(deps) {
 			pollingError = "GitHub rate limit asks to wait.";
 			return {
 				failed: true,
-				retryAfterMs: tickRateLimitWaitMs
+				retryAfterMs: tickRateLimitWaitMs,
+				error: pollingError
 			};
 		}
 		if (hasSlotFreedSinceSlotCount && waitingForSlot.length > 0 && !loop.isStopped()) setTimeoutFn(() => {
@@ -24438,10 +24724,11 @@ function createTeamReviewPoller(deps) {
 			error: "Reviews polling is stopped."
 		};
 		if (watches.size === 0) await collectCandidates();
-		const refreshed = await store.refreshWatches([...watches.keys()]);
-		rebuild();
-		if (!refreshed.ok) return refreshed;
-		return loop.refresh();
+		return loop.refresh(async () => {
+			const refreshed = await store.refreshWatches([...watches.keys()]);
+			rebuild();
+			return refreshed;
+		});
 	}
 	async function stop() {
 		hasLoadedState = false;
@@ -24836,7 +25123,7 @@ function listHomeWorktreePathsMissingLock(porcelain, glimmervoidHomes) {
 }
 //#endregion
 //#region server/git/git-workspace.ts
-var fsp$1 = fs.promises;
+var fsp = fs.promises;
 var MERGE_PROBE_TIMEOUT_MS = 3e4;
 var REMOTE_REF_PREFIX = "refs/remotes/origin/";
 var REMOTE_BRANCH_LISTING_MAX_BUFFER = 67108864;
@@ -24908,7 +25195,7 @@ function comparableGlimmervoidHomes(glimmervoidHome) {
 }
 async function directoryExists$1(candidatePath) {
 	try {
-		await fsp$1.access(candidatePath);
+		await fsp.access(candidatePath);
 		return true;
 	} catch {
 		return false;
@@ -25068,13 +25355,19 @@ function createGitWorkspace(opts = {}) {
 		}
 	}
 	const runInProject = (projectPath) => (args) => run(args, projectPath);
-	async function addWorktreeEntry(runGitInProject, worktreePath, addArgs) {
+	async function addWorktreeEntry(runGitInProject, worktreePath, addArgs, ownership) {
 		const added = await runGitInProject([
 			"worktree",
 			"add",
 			...addArgs
 		]);
-		if (!added.ok || !isWorktreeHiddenFromGuardedSessions(worktreePath, glimmervoidHomes)) return added;
+		if (!added.ok) return added;
+		await opts.ownedPaths?.record({
+			path: worktreePath,
+			kind: "git-worktree",
+			...ownership
+		});
+		if (!isWorktreeHiddenFromGuardedSessions(worktreePath, glimmervoidHomes)) return added;
 		await lockWorktreeEntry(runGitInProject, worktreePath);
 		return added;
 	}
@@ -25100,12 +25393,27 @@ function createGitWorkspace(opts = {}) {
 			"unlock",
 			worktreePath
 		]);
-		return runGitInProject([
+		const removed = await runGitInProject([
 			"worktree",
 			"remove",
 			...removeFlags,
 			worktreePath
 		]);
+		await forgetRemovedPath(worktreePath);
+		return removed;
+	}
+	async function forgetRemovedPath(ownedPath) {
+		if (await directoryExists$1(ownedPath)) return;
+		await opts.ownedPaths?.forget(ownedPath);
+	}
+	async function recordOwnedFolder({ folderPath, owner }) {
+		await opts.ownedPaths?.record({
+			path: folderPath,
+			owner,
+			kind: "folder",
+			projectPath: null,
+			branch: null
+		});
 	}
 	async function pruneWorktreeEntries(runGitInProject) {
 		const listed = await runGitInProject([
@@ -25343,7 +25651,7 @@ function createGitWorkspace(opts = {}) {
 		}
 		return null;
 	}
-	async function createBody({ projectPath, teamId, label, baseBranch = null, configuredIntegrationBranch = null, forkFromHead = false, worktreeBase, shareList }) {
+	async function createBody({ projectPath, owner, teamId, label, baseBranch = null, configuredIntegrationBranch = null, forkFromHead = false, worktreeBase, shareList }) {
 		const inside = await run(["rev-parse", "--is-inside-work-tree"], projectPath);
 		if (!inside.ok || inside.out !== "true") return {
 			cwd: projectPath,
@@ -25422,7 +25730,11 @@ function createGitWorkspace(opts = {}) {
 			branch,
 			wtDir,
 			baseSha
-		]);
+		], {
+			owner,
+			projectPath,
+			branch
+		});
 		if (!add.ok) {
 			try {
 				fs.rmSync(wtDir, {
@@ -25470,7 +25782,7 @@ function createGitWorkspace(opts = {}) {
 		if (keepTrackableLinks) return;
 		await refuseTrackableLinks(wtDir, ignored);
 	}
-	async function ensureWorkspaceMemberBody({ projectPath, wtDir, branch, shareList }) {
+	async function ensureWorkspaceMemberBody({ projectPath, owner, wtDir, branch, shareList }) {
 		if (!wtDir || !branch) return {
 			cwd: projectPath,
 			isGit: false,
@@ -25521,7 +25833,11 @@ function createGitWorkspace(opts = {}) {
 			"--quiet",
 			`refs/heads/${branch}`
 		], projectPath)).ok) {
-			const attached = await addWorktreeEntry(runInProject(projectPath), wtDir, [wtDir, branch]);
+			const attached = await addWorktreeEntry(runInProject(projectPath), wtDir, [wtDir, branch], {
+				owner,
+				projectPath,
+				branch
+			});
 			if (!attached.ok) return {
 				cwd: projectPath,
 				isGit: false,
@@ -25572,7 +25888,11 @@ function createGitWorkspace(opts = {}) {
 			branch,
 			wtDir,
 			baseSha
-		]);
+		], {
+			owner,
+			projectPath,
+			branch
+		});
 		if (!added.ok) return {
 			cwd: projectPath,
 			isGit: false,
@@ -25601,11 +25921,11 @@ function createGitWorkspace(opts = {}) {
 				rel
 			], wtDir)).ok) continue;
 			const target = path.join(wtDir, rel);
-			const stat = await fsp$1.lstat(target).catch(() => null);
+			const stat = await fsp.lstat(target).catch(() => null);
 			if (!stat || !stat.isSymbolicLink()) continue;
 			console.warn(`[git-workspace] not sharing ${rel}: git does not ignore it as a link, so a commit in the worktree would carry it (use a slash-free .gitignore entry)`);
 			try {
-				await fsp$1.rm(target, { force: true });
+				await fsp.rm(target, { force: true });
 			} catch {}
 		}
 	}
@@ -25866,7 +26186,7 @@ function createGitWorkspace(opts = {}) {
 		for (const [index, segment] of pathSegments.entries()) {
 			if (!segment || segment === "." || segment === "..") return false;
 			checkedPath = path.join(checkedPath, segment);
-			const entryStats = await fsp$1.lstat(checkedPath).catch(() => null);
+			const entryStats = await fsp.lstat(checkedPath).catch(() => null);
 			if (!entryStats) return false;
 			if (index === pathSegments.length - 1) return entryStats.isFile();
 			if (!entryStats.isDirectory()) return false;
@@ -26096,7 +26416,7 @@ function createGitWorkspace(opts = {}) {
 		], projectPath);
 		await pruneWorktreeEntries(runInProject(projectPath));
 	}
-	async function probeWorktreeWork({ projectPath, cwd, branch, integrationBranch, configuredIntegrationBranch }) {
+	async function probeWorktreeWork({ projectPath, cwd, branch, measuredTip = branch, integrationBranch, configuredIntegrationBranch }) {
 		const { base: resolvedIntegrationBranch, measureRef } = await migrateMarkerBase(projectPath, branch, integrationBranch, configuredIntegrationBranch);
 		const dirty = await run(WORK_PRESENCE_STATUS_ARGS, cwd);
 		return {
@@ -26104,11 +26424,32 @@ function createGitWorkspace(opts = {}) {
 			ahead: !isDirtyResult(dirty) && resolvedIntegrationBranch ? await run([
 				"rev-list",
 				"--count",
-				`${measureRef || resolvedIntegrationBranch}..${branch}`
+				`${measureRef || resolvedIntegrationBranch}..${measuredTip}`
 			], projectPath) : null,
 			integrationBranch: resolvedIntegrationBranch ?? null
 		};
 	}
+	async function describeWorkspaceMemberWorkBody({ projectPath, cwd, branch }) {
+		const memberHead = await run([
+			"rev-parse",
+			"--verify",
+			"HEAD"
+		], cwd);
+		if (!memberHead.ok || !memberHead.out) return "its checked-out commit could not be read";
+		const integrationBranch = await detectDefaultBranch({ projectPath });
+		const { dirty, ahead, integrationBranch: comparedBranch } = await probeWorktreeWork({
+			projectPath,
+			cwd,
+			branch,
+			measuredTip: memberHead.out,
+			integrationBranch
+		});
+		if (!dirty.ok) return "its git status could not be read";
+		if (isDirtyResult(dirty)) return "uncommitted changes";
+		if (!ahead?.ok) return "its commits could not be compared with the base branch";
+		if (!ahead.out || ahead.out === "0") return null;
+		return `${ahead.out} ${ahead.out === "1" ? "commit" : "commits"} not on ${comparedBranch}`;
+	}
 	async function hasUnmergedWorkBody({ projectPath, workspace, integrationBranch, configuredIntegrationBranch }) {
 		if (!workspace || !workspace.isGit || !workspace.cwd || !workspace.branch) return true;
 		const { dirty, ahead } = await probeWorktreeWork({
@@ -26314,7 +26655,7 @@ function createGitWorkspace(opts = {}) {
 		for (const rel of shareList ?? []) {
 			if (!rel || String(rel).includes("..")) continue;
 			const linkPath = path.join(wtDir, rel);
-			const stat = await fsp$1.lstat(linkPath).catch(() => null);
+			const stat = await fsp.lstat(linkPath).catch(() => null);
 			if (!stat || !stat.isSymbolicLink()) continue;
 			if (!(await run([
 				"check-ignore",
@@ -26322,21 +26663,30 @@ function createGitWorkspace(opts = {}) {
 				"--",
 				rel
 			], wtDir)).ok) continue;
-			await fsp$1.rm(linkPath, {
+			await fsp.rm(linkPath, {
 				recursive: false,
 				force: true
-			}).catch(() => fsp$1.rmdir(linkPath)).catch(() => {});
+			}).catch(() => fsp.rmdir(linkPath)).catch(() => {});
 		}
 	}
-	async function removeWorkspaceMemberBody({ projectPath, cwd, shareList }) {
+	async function removeWorkspaceMemberBody({ projectPath, cwd, shareList, discardWork = false }) {
 		if (!cwd) return {
 			ok: false,
 			out: "",
 			err: "a workspace member removal needs a path"
 		};
 		await removeSharedLinks(cwd, shareList);
-		const removed = await removeWorktreeEntry(runInProject(projectPath), cwd, []);
+		const removed = await removeWorktreeEntry(runInProject(projectPath), cwd, discardWork ? ["--force", "--force"] : []);
+		if (discardWork && await directoryExists$1(cwd)) await fsp.rm(cwd, {
+			recursive: true,
+			force: true
+		});
 		await pruneWorktreeEntries(runInProject(projectPath));
+		await forgetRemovedPath(cwd);
+		if (discardWork && !await directoryExists$1(cwd)) return {
+			ok: true,
+			out: removed.out
+		};
 		return removed;
 	}
 	async function listWorktreeBranches({ projectPath }) {
@@ -26457,7 +26807,7 @@ function createGitWorkspace(opts = {}) {
 		if (!updated.ok) return updated;
 		return okResult(originSha);
 	}
-	async function stageDetachedWorktreeBody({ projectPath, worktreePath, sha, disableHooks, replaceEnv }) {
+	async function stageDetachedWorktreeBody({ projectPath, worktreePath, sha, owner, disableHooks, replaceEnv }) {
 		if (!worktreePath) return {
 			ok: false,
 			out: "",
@@ -26475,7 +26825,11 @@ function createGitWorkspace(opts = {}) {
 			"--detach",
 			worktreePath,
 			sha
-		]);
+		], {
+			owner,
+			projectPath,
+			branch: null
+		});
 	}
 	async function checkoutDetachedBody({ worktreePath, sha, ...isolation }) {
 		if (!worktreePath) return {
@@ -26534,8 +26888,8 @@ function createGitWorkspace(opts = {}) {
 			err: commonDir.err || "the source repository has no git dir"
 		};
 		const sourceObjectsDir = path.join(path.resolve(projectPath, commonDir.out), "objects");
-		await fsp$1.mkdir(path.dirname(checkoutPath), { recursive: true });
-		await fsp$1.mkdir(checkoutPath);
+		await fsp.mkdir(path.dirname(checkoutPath), { recursive: true });
+		await fsp.mkdir(checkoutPath);
 		const initialized = await run([
 			"init",
 			"--quiet",
@@ -26543,8 +26897,8 @@ function createGitWorkspace(opts = {}) {
 		], checkoutPath);
 		if (!initialized.ok) return initialized;
 		const alternatesPath = path.join(checkoutPath, ".git", "objects", "info", "alternates");
-		await fsp$1.mkdir(path.dirname(alternatesPath), { recursive: true });
-		await fsp$1.writeFile(alternatesPath, `${sourceObjectsDir}\n`, "utf8");
+		await fsp.mkdir(path.dirname(alternatesPath), { recursive: true });
+		await fsp.writeFile(alternatesPath, `${sourceObjectsDir}\n`, "utf8");
 		for (const [ref, refSha] of [[ISOLATED_CHECKOUT_REVIEW_REF, sha], [ISOLATED_CHECKOUT_BASE_REF, baseSha]]) {
 			const updated = await run([
 				"update-ref",
@@ -26730,7 +27084,7 @@ function createGitWorkspace(opts = {}) {
 		};
 		const addedPaths = added.out.split("\0").filter(Boolean);
 		const collidingPaths = [];
-		for (const addedPath of addedPaths) if (await fsp$1.lstat(path.join(checkoutPath, addedPath)).then(() => true, (error) => !isMissingFileError(error, { includeNotDir: false }))) collidingPaths.push(addedPath);
+		for (const addedPath of addedPaths) if (await fsp.lstat(path.join(checkoutPath, addedPath)).then(() => true, (error) => !isMissingFileError(error, { includeNotDir: false }))) collidingPaths.push(addedPath);
 		return {
 			ok: true,
 			collidingPaths
@@ -27066,6 +27420,9 @@ function createGitWorkspace(opts = {}) {
 		pruneWorktrees: serialized(pruneWorktreesBody),
 		discardSessionBranch: serialized(discardSessionBranchBody),
 		stageDetachedWorktree: serialized(stageDetachedWorktreeBody),
+		forgetRemovedPath,
+		recordOwnedFolder,
+		describeWorkspaceMemberWork: serialized(describeWorkspaceMemberWorkBody),
 		checkoutDetached: serialized(checkoutDetachedBody),
 		stageIsolatedCheckout,
 		mergeFastForwardTo,
@@ -27231,6 +27588,7 @@ function createGitWorkspaceSync(opts = {}) {
 				"--force",
 				cwd
 			], projectPath);
+			if (!fs.existsSync(cwd)) opts.ownedPaths?.forget(cwd);
 		}
 		if (branch) run([
 			"branch",
@@ -27289,10 +27647,10 @@ async function populateWorktree(projectPath, wtDir, shareList) {
 		const src = path.join(projectPath, rel);
 		const dst = path.join(wtDir, rel);
 		try {
-			const srcStat = await fsp$1.stat(src).catch(() => null);
+			const srcStat = await fsp.stat(src).catch(() => null);
 			if (!srcStat) continue;
-			if (await fsp$1.access(dst).then(() => true, (error) => !isMissingFileError(error, { includeNotDir: false }))) continue;
-			await fsp$1.mkdir(path.dirname(dst), { recursive: true });
+			if (await fsp.access(dst).then(() => true, (error) => !isMissingFileError(error, { includeNotDir: false }))) continue;
+			await fsp.mkdir(path.dirname(dst), { recursive: true });
 			if (srcStat.isDirectory()) {
 				if (process.platform === "win32") {
 					await execFileAsync("cmd", [
@@ -27304,10 +27662,10 @@ async function populateWorktree(projectPath, wtDir, shareList) {
 					]);
 					continue;
 				}
-				await fsp$1.symlink(src, dst, "dir");
+				await fsp.symlink(src, dst, "dir");
 				continue;
 			}
-			await fsp$1.copyFile(src, dst);
+			await fsp.copyFile(src, dst);
 		} catch {}
 	}
 }
@@ -27460,7 +27818,7 @@ async function describeTeamReviewRole({ checkoutPath, cachedClone, linkedCheckou
 }
 async function linkedCheckoutUnreadablePaths(linkedCheckout) {
 	if (linkedCheckout === null) return [];
-	return (await fsp.readdir(linkedCheckout)).filter((entryName) => LINKED_CHECKOUT_UNREADABLE_ENTRY.test(entryName)).map((entryName) => path.join(linkedCheckout, entryName));
+	return (await fs$1.readdir(linkedCheckout)).filter((entryName) => LINKED_CHECKOUT_UNREADABLE_ENTRY.test(entryName)).map((entryName) => path.join(linkedCheckout, entryName));
 }
 function teamReviewClaudeArgs(tier, readable) {
 	const model = tier === "full" ? FULL_MODEL : STAMP_MODEL;
@@ -27511,11 +27869,11 @@ function hooksPathPinnedSpawnEnv(workDir) {
 }
 async function makeTeamReviewWorkDir(root, prefix) {
 	const safePrefix = `glimmervoid-wt-${TEAM_REVIEW_LANE_ID}-${prefix}`.replace(/[^\w.-]+/g, "-");
-	await fsp.mkdir(root, { recursive: true });
-	const dir = await fsp.mkdtemp(path.join(root, `${safePrefix}-`));
+	await fs$1.mkdir(root, { recursive: true });
+	const dir = await fs$1.mkdtemp(path.join(root, `${safePrefix}-`));
 	return {
 		dir,
-		cleanup: () => fsp.rm(dir, {
+		cleanup: () => fs$1.rm(dir, {
 			recursive: true,
 			force: true
 		}).catch(() => {})
@@ -27524,11 +27882,11 @@ async function makeTeamReviewWorkDir(root, prefix) {
 async function readReviewReport(reportPath, expectedHead, isReReview) {
 	let report;
 	try {
-		if ((await fsp.stat(reportPath)).size > RESULT_MAX_BYTES$1) return {
+		if ((await fs$1.stat(reportPath)).size > RESULT_MAX_BYTES$1) return {
 			ok: false,
 			reason: "the review report is too large"
 		};
-		report = await fsp.readFile(reportPath, "utf8");
+		report = await fs$1.readFile(reportPath, "utf8");
 	} catch {
 		return {
 			ok: false,
@@ -27549,11 +27907,11 @@ async function readReviewReport(reportPath, expectedHead, isReReview) {
 async function readPostingPlan(postingPath, expectedHead, log) {
 	let json;
 	try {
-		if ((await fsp.stat(postingPath)).size > RESULT_MAX_BYTES$1) {
+		if ((await fs$1.stat(postingPath)).size > RESULT_MAX_BYTES$1) {
 			log.warn(`[${TEAM_REVIEW_LANE_ID}] the posting plan is too large, rendering from the findings instead`);
 			return null;
 		}
-		json = await fsp.readFile(postingPath, "utf8");
+		json = await fs$1.readFile(postingPath, "utf8");
 	} catch {
 		return null;
 	}
@@ -27566,7 +27924,7 @@ function worktreeDirName(repo, number, suffix) {
 	return `glimmervoid-wt-${TEAM_REVIEW_LANE_ID}-${repo.replace(/[^\w.-]+/g, "-")}-${number}-${suffix}`;
 }
 async function pathExists(candidatePath) {
-	return fsp.lstat(candidatePath).then(() => true, () => false);
+	return fs$1.lstat(candidatePath).then(() => true, () => false);
 }
 function isDirectChildOf(root, candidatePath) {
 	return path.dirname(path.resolve(candidatePath)) === path.resolve(root);
@@ -27576,10 +27934,10 @@ function isOwnedResumable(record, roots) {
 }
 async function isRealChildDirectoryOrMissing(root, candidatePath) {
 	if (!isDirectChildOf(root, candidatePath)) return false;
-	const candidateStat = await fsp.lstat(candidatePath).catch((error) => isMissingFileError(error, { includeNotDir: false }) ? "missing" : null);
+	const candidateStat = await fs$1.lstat(candidatePath).catch((error) => isMissingFileError(error, { includeNotDir: false }) ? "missing" : null);
 	if (candidateStat === "missing") return true;
 	if (!candidateStat?.isDirectory()) return false;
-	const realPaths = await Promise.all([fsp.realpath(candidatePath), fsp.realpath(root)]).catch(() => null);
+	const realPaths = await Promise.all([fs$1.realpath(candidatePath), fs$1.realpath(root)]).catch(() => null);
 	if (!realPaths) return false;
 	const [realCandidatePath, realRootPath] = realPaths;
 	return path.dirname(realCandidatePath) === realRootPath;
@@ -27596,13 +27954,17 @@ async function pruneCachedClone(gitWorkspace, projectPath, log) {
 	if (!pruned.ok) log.warn(`[${TEAM_REVIEW_LANE_ID}] worktree prune failed in ${projectPath}: ${firstLine$1(pruned.err ?? "")}`);
 }
 async function deleteDirectory(directory, log) {
-	await fsp.rm(directory, {
+	await fs$1.rm(directory, {
 		recursive: true,
 		force: true
 	}).catch((error) => log.warn(`[${TEAM_REVIEW_LANE_ID}] could not delete ${directory}: ${errorMessage(error)}`));
 }
+async function deleteCheckout(gitWorkspace, worktreePath, log) {
+	await deleteDirectory(worktreePath, log);
+	await gitWorkspace.forgetRemovedPath?.(worktreePath);
+}
 async function isDirectory(candidatePath) {
-	return (await fsp.stat(candidatePath).catch(() => null))?.isDirectory() === true;
+	return (await fs$1.stat(candidatePath).catch(() => null))?.isDirectory() === true;
 }
 async function mainCheckoutOf(checkoutPath) {
 	const gitDirs = await readGitDirsOfOwnCheckout(checkoutPath).catch(() => null);
@@ -27614,17 +27976,17 @@ async function mainCheckoutOf(checkoutPath) {
 async function configuredProjectPathsByRealPath(projects) {
 	const configuredPathByRealPath = /* @__PURE__ */ new Map();
 	for (const project of projects) {
-		const projectRealPath = await fsp.realpath(project.path).catch(() => null);
+		const projectRealPath = await fs$1.realpath(project.path).catch(() => null);
 		if (projectRealPath === null || configuredPathByRealPath.has(projectRealPath)) continue;
 		configuredPathByRealPath.set(projectRealPath, project.path);
 	}
 	return configuredPathByRealPath;
 }
 async function findLocalCheckout({ repo, config, excludedRoots, gitWorkspace, log, requireInstalledModules = true, resolveCheckout }) {
-	const resolvedExcludedRoots = await Promise.all(excludedRoots.map(async (root) => fsp.realpath(root).catch(() => path.resolve(root))));
+	const resolvedExcludedRoots = await Promise.all(excludedRoots.map(async (root) => fs$1.realpath(root).catch(() => path.resolve(root))));
 	const candidatePaths = (config.projects ?? []).map((project) => project.path);
 	for (const root of config.repoRoots ?? []) {
-		const childNames = (await fsp.readdir(root, { withFileTypes: true }).catch((error) => {
+		const childNames = (await fs$1.readdir(root, { withFileTypes: true }).catch((error) => {
 			log.warn(`[${TEAM_REVIEW_LANE_ID}] could not list local repositories in ${root}: ${errorMessage(error)}`);
 			return [];
 		})).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules").map((entry) => entry.name).sort();
@@ -27632,7 +27994,7 @@ async function findLocalCheckout({ repo, config, excludedRoots, gitWorkspace, lo
 	}
 	const seenPaths = /* @__PURE__ */ new Set();
 	for (const candidatePath of candidatePaths) {
-		const checkoutPath = await fsp.realpath(candidatePath).catch(() => null);
+		const checkoutPath = await fs$1.realpath(candidatePath).catch(() => null);
 		if (!checkoutPath || seenPaths.has(checkoutPath)) continue;
 		seenPaths.add(checkoutPath);
 		if (resolvedExcludedRoots.some((root) => isPathInside(root, checkoutPath))) continue;
@@ -27646,9 +28008,9 @@ async function findLocalCheckout({ repo, config, excludedRoots, gitWorkspace, lo
 }
 async function isLinkedToCheckout(worktreePath, localCheckout) {
 	const modulesPath = path.join(worktreePath, "node_modules");
-	if (!(await fsp.lstat(modulesPath).catch(() => null))?.isSymbolicLink()) return false;
-	const linkedModules = await fsp.realpath(modulesPath).catch(() => null);
-	const checkoutModules = await fsp.realpath(path.join(localCheckout, "node_modules")).catch(() => null);
+	if (!(await fs$1.lstat(modulesPath).catch(() => null))?.isSymbolicLink()) return false;
+	const linkedModules = await fs$1.realpath(modulesPath).catch(() => null);
+	const checkoutModules = await fs$1.realpath(path.join(localCheckout, "node_modules")).catch(() => null);
 	return linkedModules !== null && linkedModules === checkoutModules;
 }
 async function sweepLeftoverCheckouts({ worktreeRoot, workRoot, keepPaths, repoCache, gitWorkspace, reapProcesses = reapTeamReviewProcesses, log }) {
@@ -27659,11 +28021,11 @@ async function sweepLeftoverCheckouts({ worktreeRoot, workRoot, keepPaths, repoC
 		log
 	}).catch((error) => log.warn(`[${TEAM_REVIEW_LANE_ID}] process reap failed: ${errorMessage(error)}`));
 	for (const root of [worktreeRoot, workRoot]) {
-		const leftoverNames = await fsp.readdir(root).catch(() => []);
+		const leftoverNames = await fs$1.readdir(root).catch(() => []);
 		for (const leftoverName of leftoverNames) {
 			const directory = path.join(root, leftoverName);
 			if (keepPaths.has(directory)) continue;
-			await deleteDirectory(directory, log);
+			await deleteCheckout(gitWorkspace, directory, log);
 		}
 	}
 	const cachedClones = await repoCache.listRepos().catch((error) => {
@@ -27683,7 +28045,7 @@ function createTeamReviewDispatcher({ store, repoCache, gitWorkspace, spawnSessi
 		}));
 		if (removal.ok && !await pathExists(worktreePath)) return;
 		log.warn(`[${TEAM_REVIEW_LANE_ID}] worktree removal failed for ${worktreePath}, deleting it directly: ${firstLine$1(removal.err ?? "") || "the directory is still present"}`);
-		await deleteDirectory(worktreePath, log);
+		await deleteCheckout(gitWorkspace, worktreePath, log);
 		await pruneCachedClone(gitWorkspace, projectPath, log);
 	}
 	async function discoverLocalCheckout(repo) {
@@ -27730,7 +28092,7 @@ function createTeamReviewDispatcher({ store, repoCache, gitWorkspace, spawnSessi
 			return null;
 		}
 		const scratchObjectsDir = path.join(workDir, REMERGE_OBJECTS_DIRNAME);
-		await fsp.mkdir(scratchObjectsDir, { recursive: true });
+		await fs$1.mkdir(scratchObjectsDir, { recursive: true });
 		return {
 			...isolation.range,
 			scratchObjectsDir
@@ -27840,7 +28202,7 @@ function createTeamReviewDispatcher({ store, repoCache, gitWorkspace, spawnSessi
 				}
 			};
 			if (hasWorkDir) await deleteDirectory(args.resume.workDir, log);
-			if (hasWorktree) await deleteDirectory(args.resume.worktreePath, log);
+			if (hasWorktree) await deleteCheckout(gitWorkspace, args.resume.worktreePath, log);
 			return {
 				kind: "stopped",
 				resumable: null
@@ -27931,7 +28293,7 @@ function createTeamReviewDispatcher({ store, repoCache, gitWorkspace, spawnSessi
 						projectPath,
 						worktreePath: args.resume.worktreePath
 					});
-					if (!projectPath) await deleteDirectory(args.resume.worktreePath, log);
+					if (!projectPath) await deleteCheckout(gitWorkspace, args.resume.worktreePath, log);
 				}
 				if (hasWorkDir) await deleteDirectory(args.resume.workDir, log);
 				sessionId = null;
@@ -27955,9 +28317,10 @@ function createTeamReviewDispatcher({ store, repoCache, gitWorkspace, spawnSessi
 				projectPath: staged.projectPath,
 				worktreePath
 			};
-			await fsp.mkdir(worktreeRoot, { recursive: true });
+			await fs$1.mkdir(worktreeRoot, { recursive: true });
 			const created = await gitWorkspace.stageDetachedWorktree({
 				projectPath: staged.projectPath,
+				owner: "lane:team-review",
 				worktreePath,
 				sha: detail.headRefOid
 			});
@@ -27998,8 +28361,8 @@ function createTeamReviewDispatcher({ store, repoCache, gitWorkspace, spawnSessi
 				priorReview,
 				newWork
 			});
-			await fsp.writeFile(path.join(workDir, REVIEW_PROMPT_FILENAME), prompt, "utf8");
-			await fsp.mkdir(emptyGhConfigDir(workDir), { recursive: true });
+			await fs$1.writeFile(path.join(workDir, REVIEW_PROMPT_FILENAME), prompt, "utf8");
+			await fs$1.mkdir(emptyGhConfigDir(workDir), { recursive: true });
 			reportProgress({
 				kind: "phase",
 				phase: "reviewing",
@@ -28517,7 +28880,7 @@ function createTeamReviewWiring({ config, store, reviewSessions, closeSessionDat
 						scope: "run",
 						log
 					}).catch((error) => log.warn(`[${TEAM_REVIEW_LANE_ID}] process reap failed: ${errorMessage(error)}`));
-					await deleteDirectory(record.worktreePath, log);
+					await deleteCheckout(gitWorkspace, record.worktreePath, log);
 					await deleteDirectory(record.workDir, log);
 					const cachedClones = await repoCache.listRepos();
 					for (const projectPath of cachedClones) await pruneCachedClone(gitWorkspace, projectPath, log);
@@ -28584,7 +28947,7 @@ function createTeamReviewWiring({ config, store, reviewSessions, closeSessionDat
 			worktreeRoot,
 			workRoot
 		];
-		const resolvedExcludedRoots = await Promise.all(excludedRoots.map((root) => fsp.realpath(root).catch(() => path.resolve(root))));
+		const resolvedExcludedRoots = await Promise.all(excludedRoots.map((root) => fs$1.realpath(root).catch(() => path.resolve(root))));
 		const configuredPathByRealPath = await configuredProjectPathsByRealPath(config.projects ?? []);
 		return findLocalCheckout({
 			repo,
@@ -28878,18 +29241,18 @@ function worktreeOwnerRepo(gitFileText) {
 async function readJsonFile$1(filePath) {
 	return loadedJsonValue(await loadJsonStateFile({
 		filePath,
-		fsPromises: fsp,
+		fsPromises: fs$1,
 		parse: (raw) => raw,
 		quarantine: false
 	}));
 }
 async function jsonFileNames(directory) {
-	return (await fsp.readdir(directory, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name).sort();
+	return (await fs$1.readdir(directory, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name).sort();
 }
 async function readBoundedText(filePath) {
-	const stat = await fsp.stat(filePath).catch(() => null);
+	const stat = await fs$1.stat(filePath).catch(() => null);
 	if (!stat?.isFile() || stat.size > RESULT_MAX_BYTES) return null;
-	return fsp.readFile(filePath, "utf8").catch(() => null);
+	return fs$1.readFile(filePath, "utf8").catch(() => null);
 }
 function createBenchmarkWiring({ benchmarksRoot, runsRoot, isEnabled, broadcast, store, repoCache, repoCacheRoot, gitWorkspace, spawnSubject, spawnJudge, credentials, claudeCommand, runArmCommand = runArmCommandSafely, guardrailsRefusal = allowGuardedSpawn, baseEnv = process.env, now = () => Date.now(), randomSuffix = () => randomBytes(4).toString("hex"), log = console }) {
 	let activeRun = null;
@@ -28898,7 +29261,7 @@ function createBenchmarkWiring({ benchmarksRoot, runsRoot, isEnabled, broadcast,
 	let leftoverSweep = Promise.resolve();
 	const suiteDir = (suiteId) => path.join(benchmarksRoot, suiteId);
 	async function removeDirectoryOrWarn(directory) {
-		await fsp.rm(directory, {
+		await fs$1.rm(directory, {
 			recursive: true,
 			force: true
 		}).catch((error) => log.warn(`[${BENCHMARK_LANE_ID}] could not remove ${directory}: ${firstLine(errorMessage(error))}`));
@@ -28997,7 +29360,7 @@ function createBenchmarkWiring({ benchmarksRoot, runsRoot, isEnabled, broadcast,
 		return refreshed;
 	}
 	async function summarizeAndBroadcast() {
-		const suiteIds = (await fsp.readdir(benchmarksRoot, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isDirectory() && BenchmarkId.safeParse(entry.name).success).map((entry) => entry.name).sort();
+		const suiteIds = (await fs$1.readdir(benchmarksRoot, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isDirectory() && BenchmarkId.safeParse(entry.name).success).map((entry) => entry.name).sort();
 		const summaries = [];
 		for (const suiteId of suiteIds) summaries.push(await summarizeSuite(suiteId).catch((error) => unreadableSuiteSummary(suiteId, errorMessage(error))));
 		suites = summaries;
@@ -29054,7 +29417,7 @@ function createBenchmarkWiring({ benchmarksRoot, runsRoot, isEnabled, broadcast,
 			error: mined.reason
 		};
 		const candidatesDir = path.join(suiteDir(suiteId), "candidates");
-		await fsp.mkdir(candidatesDir, { recursive: true });
+		await fs$1.mkdir(candidatesDir, { recursive: true });
 		for (const outcome of mined.outcomes) {
 			if (!outcome.candidate) {
 				log.warn(`[${BENCHMARK_LANE_ID}] ${caseSource.repo}#${outcome.number} not mined: ${outcome.refusal}`);
@@ -29150,7 +29513,7 @@ function createBenchmarkWiring({ benchmarksRoot, runsRoot, isEnabled, broadcast,
 				reason: "the reviewed commit could not be fetched, or the base is not its ancestor"
 			};
 			const checkoutPath = path.join(staged.caseDir, "checkout");
-			const cleared = await fsp.rm(checkoutPath, {
+			const cleared = await fs$1.rm(checkoutPath, {
 				recursive: true,
 				force: true
 			}).then(() => null, (error) => errorMessage(error));
@@ -29171,7 +29534,7 @@ function createBenchmarkWiring({ benchmarksRoot, runsRoot, isEnabled, broadcast,
 					reason: `could not stage a checkout: ${firstLine(created.err ?? "") || "the isolated checkout failed"}`
 				};
 			}
-			const sharedObjectsPath = firstLine(await fsp.readFile(path.join(checkoutPath, ".git", "objects", "info", "alternates"), "utf8").catch(() => ""));
+			const sharedObjectsPath = firstLine(await fs$1.readFile(path.join(checkoutPath, ".git", "objects", "info", "alternates"), "utf8").catch(() => ""));
 			if (!sharedObjectsPath) {
 				await removeDirectoryOrWarn(checkoutPath);
 				return {
@@ -29189,7 +29552,7 @@ function createBenchmarkWiring({ benchmarksRoot, runsRoot, isEnabled, broadcast,
 			if (existing) return existing;
 			const caseDir = path.join(runDir, benchmarkCase.id);
 			const workDir = path.join(caseDir, "work");
-			await fsp.mkdir(workDir, { recursive: true });
+			await fs$1.mkdir(workDir, { recursive: true });
 			const staged = {
 				checkoutPath: null,
 				sharedObjectsPath: null,
@@ -29272,7 +29635,7 @@ function createBenchmarkWiring({ benchmarksRoot, runsRoot, isEnabled, broadcast,
 			},
 			judgeSeed: (cell) => cell.index + 1,
 			async persist(run) {
-				await fsp.mkdir(runsDir, { recursive: true });
+				await fs$1.mkdir(runsDir, { recursive: true });
 				await writeJsonAtomic(path.join(runsDir, `${runId}.json`), redactedRun(run, usedTokens));
 			},
 			reportProgress
@@ -29299,10 +29662,10 @@ function createBenchmarkWiring({ benchmarksRoot, runsRoot, isEnabled, broadcast,
 		};
 		usedTokens.add(token.token);
 		const resultPath = path.join(staged.workDir, SUBJECT_RESULT_FILENAME);
-		await fsp.rm(resultPath, { force: true });
-		await fsp.writeFile(path.join(staged.workDir, SUBJECT_PROMPT_FILENAME), prompt, "utf8");
+		await fs$1.rm(resultPath, { force: true });
+		await fs$1.writeFile(path.join(staged.workDir, SUBJECT_PROMPT_FILENAME), prompt, "utf8");
 		const baseSpawnEnv = hooksPathPinnedSpawnEnv(staged.workDir);
-		await fsp.mkdir(baseSpawnEnv.GH_CONFIG_DIR, { recursive: true });
+		await fs$1.mkdir(baseSpawnEnv.GH_CONFIG_DIR, { recursive: true });
 		const subjectController = new AbortController();
 		const stopSubject = () => subjectController.abort();
 		let hasTimedOut = false;
@@ -29364,8 +29727,8 @@ function createBenchmarkWiring({ benchmarksRoot, runsRoot, isEnabled, broadcast,
 		};
 	}
 	async function runJudgeSession({ cell, prompt, model, signal, runDir }) {
-		await fsp.mkdir(runDir, { recursive: true });
-		const judgeDir = await fsp.mkdtemp(path.join(runDir, `judge-${cell.index}-`));
+		await fs$1.mkdir(runDir, { recursive: true });
+		const judgeDir = await fs$1.mkdtemp(path.join(runDir, `judge-${cell.index}-`));
 		const resultPath = path.join(judgeDir, JUDGE_RESULT_FILENAME);
 		try {
 			await spawnJudge({
@@ -29394,7 +29757,7 @@ function createBenchmarkWiring({ benchmarksRoot, runsRoot, isEnabled, broadcast,
 				costUsd: null
 			};
 		} finally {
-			await fsp.rm(judgeDir, {
+			await fs$1.rm(judgeDir, {
 				recursive: true,
 				force: true
 			}).catch(() => {});
@@ -29480,7 +29843,7 @@ function createBenchmarkWiring({ benchmarksRoot, runsRoot, isEnabled, broadcast,
 		return respond(outcome);
 	}
 	async function removeLeftoverWorktree(worktreePath) {
-		const projectPath = worktreeOwnerRepo(await fsp.readFile(path.join(worktreePath, ".git"), "utf8").catch(() => ""));
+		const projectPath = worktreeOwnerRepo(await fs$1.readFile(path.join(worktreePath, ".git"), "utf8").catch(() => ""));
 		if (projectPath) {
 			const removal = await gitWorkspace.removeWorktreeByPath({
 				projectPath,
@@ -29507,7 +29870,7 @@ function createBenchmarkWiring({ benchmarksRoot, runsRoot, isEnabled, broadcast,
 	}
 	async function sweepSuiteLeftovers(suiteId) {
 		const worktreesDir = path.join(suiteDir(suiteId), "worktrees");
-		const worktreeEntries = await fsp.readdir(worktreesDir, { withFileTypes: true }).catch(() => []);
+		const worktreeEntries = await fs$1.readdir(worktreesDir, { withFileTypes: true }).catch(() => []);
 		for (const entry of worktreeEntries) if (entry.isDirectory()) await removeLeftoverWorktree(path.join(worktreesDir, entry.name));
 		await removeDirectoryOrWarn(worktreesDir);
 		await removeDirectoryOrWarn(path.join(suiteDir(suiteId), "work"));
@@ -29516,7 +29879,7 @@ function createBenchmarkWiring({ benchmarksRoot, runsRoot, isEnabled, broadcast,
 	async function sweepAllLeftovers() {
 		if (activeRun) return;
 		await removeDirectoryOrWarn(runsRoot);
-		const suiteIds = (await fsp.readdir(benchmarksRoot, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isDirectory() && BenchmarkId.safeParse(entry.name).success).map((entry) => entry.name);
+		const suiteIds = (await fs$1.readdir(benchmarksRoot, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isDirectory() && BenchmarkId.safeParse(entry.name).success).map((entry) => entry.name);
 		for (const suiteId of suiteIds) await sweepSuiteLeftovers(suiteId).catch((error) => log.warn(`[${BENCHMARK_LANE_ID}] could not sweep ${suiteId}: ${errorMessage(error)}`));
 	}
 	function sweepLeftovers() {
@@ -30662,7 +31025,7 @@ function createCoderEnvWiring({ config, persistMapping, onReconciled = () => {},
 var DEFAULT_INTERVAL_MS$1 = 216e5;
 var BRANCH_GC_FETCH_TIMEOUT_MS = 6e4;
 function createBranchGcPoller(deps) {
-	const { gitWorkspace, getConfig, liveSessionIds, liveWorktreePaths, staleDays = 14, deleteUnmerged = false, prefixes = DEFAULT_BRANCH_GC_PREFIXES, pruneWorktrees = true, dryRun = false, intervalMs = DEFAULT_INTERVAL_MS$1, setIntervalFn = DEFAULT_TIMER_FNS.setIntervalFn, clearIntervalFn = DEFAULT_TIMER_FNS.clearIntervalFn, log = console, decisionTrace = () => {}, onTickComplete = () => {}, now = () => Date.now(), statProjectPath = (projectPath) => fsp.stat(projectPath) } = deps;
+	const { gitWorkspace, getConfig, liveSessionIds, liveWorktreePaths, staleDays = 14, deleteUnmerged = false, prefixes = DEFAULT_BRANCH_GC_PREFIXES, pruneWorktrees = true, dryRun = false, intervalMs = DEFAULT_INTERVAL_MS$1, setIntervalFn = DEFAULT_TIMER_FNS.setIntervalFn, clearIntervalFn = DEFAULT_TIMER_FNS.clearIntervalFn, log = console, decisionTrace = () => {}, onTickComplete = () => {}, now = () => Date.now(), statProjectPath = (projectPath) => fs$1.stat(projectPath) } = deps;
 	const skippedProjectPaths = /* @__PURE__ */ new Set();
 	async function callGit(method, args) {
 		try {
@@ -33403,7 +33766,7 @@ function classifyGitStatusFailure(error) {
 var DEFAULT_MAX_REPOS = 16;
 var DEFAULT_GIT_TIMEOUT_MS = 15e3;
 var MAX_GIT_BUFFER_BYTES = 8388608;
-function createGitIngest({ publish, sourceConfig = {}, reposProvider = null, logger = console, execFileFn = execFileAsync, createWatch = createWatchDebounce, canonicalize = canonicalizePath, statRepoDir = (dir) => fsp.stat(dir), nowFn = Date.now, setIntervalFn = DEFAULT_TIMER_FNS.setIntervalFn, clearIntervalFn = DEFAULT_TIMER_FNS.clearIntervalFn, setTimeoutFn = DEFAULT_TIMER_FNS.setTimeoutFn, clearTimeoutFn = DEFAULT_TIMER_FNS.clearTimeoutFn, maxRepos = DEFAULT_MAX_REPOS, gitTimeoutMs = DEFAULT_GIT_TIMEOUT_MS, gitPath = "git" } = {}) {
+function createGitIngest({ publish, sourceConfig = {}, reposProvider = null, logger = console, execFileFn = execFileAsync, createWatch = createWatchDebounce, canonicalize = canonicalizePath, statRepoDir = (dir) => fs$1.stat(dir), nowFn = Date.now, setIntervalFn = DEFAULT_TIMER_FNS.setIntervalFn, clearIntervalFn = DEFAULT_TIMER_FNS.clearIntervalFn, setTimeoutFn = DEFAULT_TIMER_FNS.setTimeoutFn, clearTimeoutFn = DEFAULT_TIMER_FNS.clearTimeoutFn, maxRepos = DEFAULT_MAX_REPOS, gitTimeoutMs = DEFAULT_GIT_TIMEOUT_MS, gitPath = "git" } = {}) {
 	if (typeof publish !== "function") throw new Error("createGitIngest requires publish");
 	const publishEvent = publish;
 	const settleMs = positiveIntOr(sourceConfig.debounceMs, DEFAULT_DEBOUNCE_MS);
@@ -34826,10 +35189,10 @@ function hasAutoSessionName(session) {
 	return isAutoNameOf(session.name, path.basename(session.path));
 }
 async function refineTaskTitle(request, model, spawnLane, signal) {
-	const workDir = await fsp.mkdtemp(path.join(os.tmpdir(), "glimmervoid-task-title-"));
+	const workDir = await fs$1.mkdtemp(path.join(os.tmpdir(), "glimmervoid-task-title-"));
 	const resultPath = path.join(workDir, RESULT_FILE$1);
 	try {
-		await fsp.writeFile(path.join(workDir, PROMPT_FILE$1), buildTaskTitleRefinementPrompt({
+		await fs$1.writeFile(path.join(workDir, PROMPT_FILE$1), buildTaskTitleRefinementPrompt({
 			currentTitle: request.currentTitle,
 			recentPrompts: request.recentPrompts,
 			resultPath,
@@ -34852,7 +35215,7 @@ async function refineTaskTitle(request, model, spawnLane, signal) {
 			proposedSessionName: request.wantsSessionName ? parseRefinedSessionName(laneResult) : null
 		};
 	} finally {
-		await fsp.rm(workDir, {
+		await fs$1.rm(workDir, {
 			recursive: true,
 			force: true
 		});
@@ -37939,6 +38302,7 @@ function createRadarWiring({ config, investigationSessions, closeSessionDataClie
 		const issueId = safeIssueId(issue.issueId);
 		const workspace = await Promise.resolve(gitWorkspace.create({
 			projectPath: repoPath,
+			owner: "lane:radar-fix",
 			teamId: "radar-fix",
 			label: `${safeIssueId(projectId)}-${issueId}-${newFixDiscriminator()}`,
 			worktreeBase: worktreeBaseFor(repoPath),
@@ -38446,9 +38810,13 @@ function createMyPrsPoller(dependencies) {
 	});
 	async function failedOutcome(errorText) {
 		const rateLimitWaitMs = await store.rateLimitWaitMs(now(), MY_PRS_RATE_LIMIT_RESOURCES) ?? secondaryRateLimitWaitMs(errorText);
-		return rateLimitWaitMs === null ? { failed: true } : {
+		return rateLimitWaitMs === null ? {
 			failed: true,
-			retryAfterMs: rateLimitWaitMs
+			error: errorText
+		} : {
+			failed: true,
+			retryAfterMs: rateLimitWaitMs,
+			error: errorText
 		};
 	}
 	async function runTick() {
@@ -38775,10 +39143,11 @@ function createMyPrsPoller(dependencies) {
 			error: "Reviews polling is stopped."
 		};
 		registerWatches();
-		const refreshed = await store.refreshWatches(watchNames);
-		rebuild();
-		if (!refreshed.ok) return refreshed;
-		return loop.refresh();
+		return loop.refresh(async () => {
+			const refreshed = await store.refreshWatches(watchNames);
+			rebuild();
+			return refreshed;
+		});
 	}
 	return {
 		start,
@@ -38801,10 +39170,10 @@ function defaultAgentSearchRoots() {
 	return roots.filter((root, index) => roots.indexOf(root) === index);
 }
 async function readEntryNames(directory) {
-	return fsp.readdir(directory).catch(() => []);
+	return fs$1.readdir(directory).catch(() => []);
 }
 async function ownedSocketAt(socketPath, ownerUid) {
-	const stats = await fsp.lstat(socketPath).catch(() => null);
+	const stats = await fs$1.lstat(socketPath).catch(() => null);
 	if (!stats?.isSocket()) return null;
 	if (ownerUid !== null && stats.uid !== ownerUid) return null;
 	return {
@@ -38852,12 +39221,12 @@ function createSshSigner({ env = process.env, agentSearchRoots = defaultAgentSea
 			ok: false,
 			error: NO_AGENT_HOLDS_KEY
 		};
-		const workDir = await fsp.mkdtemp(path.join(os.tmpdir(), "glimmervoid-sign-"));
+		const workDir = await fs$1.mkdtemp(path.join(os.tmpdir(), "glimmervoid-sign-"));
 		try {
 			const keyPath = path.join(workDir, "signing-key.pub");
 			const payloadPath = path.join(workDir, "payload");
-			await fsp.writeFile(keyPath, `${formatSshPublicKey(publicKey)}\n`, { mode: 384 });
-			await fsp.writeFile(payloadPath, payload, { mode: 384 });
+			await fs$1.writeFile(keyPath, `${formatSshPublicKey(publicKey)}\n`, { mode: 384 });
+			await fs$1.writeFile(payloadPath, payload, { mode: 384 });
 			await execFileAsync("ssh-keygen", [
 				"-Y",
 				"sign",
@@ -38877,7 +39246,7 @@ function createSshSigner({ env = process.env, agentSearchRoots = defaultAgentSea
 			});
 			return {
 				ok: true,
-				signature: await fsp.readFile(`${payloadPath}.sig`, "utf8")
+				signature: await fs$1.readFile(`${payloadPath}.sig`, "utf8")
 			};
 		} catch (error) {
 			const stderr = error?.stderr;
@@ -38886,7 +39255,7 @@ function createSshSigner({ env = process.env, agentSearchRoots = defaultAgentSea
 				error: `ssh-keygen could not sign: ${typeof stderr === "string" && stderr.trim() ? stderr.trim() : errorMessage(error)}`
 			};
 		} finally {
-			await fsp.rm(workDir, {
+			await fs$1.rm(workDir, {
 				recursive: true,
 				force: true
 			});
@@ -38901,7 +39270,7 @@ async function readSigningKeySetting(setting, cwd) {
 	const literalKey = parseSshPublicKey(setting);
 	if (literalKey) return literalKey;
 	const keyPath = path.resolve(cwd, setting.replace(/^~(?=\/|$)/, os.homedir()));
-	return parseSshPublicKey(await fsp.readFile(keyPath, "utf8").catch(() => ""));
+	return parseSshPublicKey(await fs$1.readFile(keyPath, "utf8").catch(() => ""));
 }
 function readTextOrNull(filePath) {
 	try {
@@ -39089,8 +39458,8 @@ function createGuardedPrStaging({ spawnSession, repoCache, describeRole = guarde
 			if (!staged.ok) return { error: `could not stage the checkout ${staged.err}` };
 		}
 		const excludePath = path.join(checkoutPath, ".git", "info", "exclude");
-		await fsp.mkdir(path.dirname(excludePath), { recursive: true });
-		await fsp.appendFile(excludePath, keepMergeableExcludeLines(), "utf8");
+		await fs$1.mkdir(path.dirname(excludePath), { recursive: true });
+		await fs$1.appendFile(excludePath, keepMergeableExcludeLines(), "utf8");
 		return {
 			projectPath,
 			baseSha: baseSha.data
@@ -39283,7 +39652,7 @@ function createMyPrMergeabilityFix({ spawnSession, repoCache, workRoot, makeWork
 		};
 	}
 	async function fetchSessionCommits(staged, checkoutPath, headSha, handoffRef, signal) {
-		const bundleDir = await fsp.mkdtemp(path.join(os.tmpdir(), "glimmervoid-keep-mergeable-"));
+		const bundleDir = await fs$1.mkdtemp(path.join(os.tmpdir(), "glimmervoid-keep-mergeable-"));
 		try {
 			const bundlePath = path.join(bundleDir, "session.bundle");
 			const bundled = await runGit([
@@ -39305,7 +39674,7 @@ function createMyPrMergeabilityFix({ spawnSession, repoCache, workRoot, makeWork
 				`+${KEEP_MERGEABLE_WORK_BRANCH_REF}:${handoffRef}`
 			], staged.projectPath, signal);
 		} finally {
-			await fsp.rm(bundleDir, {
+			await fs$1.rm(bundleDir, {
 				recursive: true,
 				force: true
 			});
@@ -39390,8 +39759,8 @@ function createMyPrMergeabilityFix({ spawnSession, repoCache, workRoot, makeWork
 			if ("error" in staged) return reportRepairFailure(pr, `not started: ${staged.error}`);
 			projectPath = staged.projectPath;
 			if (signal.aborted) return stopped;
-			await fsp.writeFile(path.join(workDir.dir, MY_PRS_FIX_PROMPT_FILENAME), keepMergeablePrompt(pr), "utf8");
-			await fsp.mkdir(emptyGhConfigDir(workDir.dir), { recursive: true });
+			await fs$1.writeFile(path.join(workDir.dir, MY_PRS_FIX_PROMPT_FILENAME), keepMergeablePrompt(pr), "utf8");
+			await fs$1.mkdir(emptyGhConfigDir(workDir.dir), { recursive: true });
 			const outcome = await runSession({
 				idPrefix: MY_PRS_LANE_ID,
 				name: `Keep mergeable ${pr.key}`,
@@ -40230,12 +40599,16 @@ function createWorkflowsPoller(dependencies) {
 		return stateLoad;
 	}
 	function publishStatus() {
+		const { nextAttemptAt, retry, isRefreshing, refreshNotice } = loop.scheduleStatus();
 		onTickComplete({
 			type: "workflows-status",
 			ts: now(),
 			configured: true,
 			error: pollingError,
-			...loop.scheduleStatus()
+			nextAttemptAt,
+			retry,
+			isRefreshing,
+			refreshNotice
 		});
 	}
 	const loop = createTickLoop({
@@ -40415,8 +40788,8 @@ function createWorkflowSpawn({ staging, workRoot, makeWorkDir = makeTeamReviewWo
 			const staged = await staging.stageCheckout(pr, workDir.dir, signal);
 			if (signal.aborted) return;
 			if ("error" in staged) return warn(`not started: ${staged.error}`);
-			await fsp.writeFile(path.join(workDir.dir, WORKFLOW_PROMPT_FILENAME), workflowSpawnPrompt(action.promptTemplate, event, MY_PRS_FIX_CHECKOUT_DIRNAME), "utf8");
-			await fsp.mkdir(emptyGhConfigDir(workDir.dir), { recursive: true });
+			await fs$1.writeFile(path.join(workDir.dir, WORKFLOW_PROMPT_FILENAME), workflowSpawnPrompt(action.promptTemplate, event, MY_PRS_FIX_CHECKOUT_DIRNAME), "utf8");
+			await fs$1.mkdir(emptyGhConfigDir(workDir.dir), { recursive: true });
 			if (await staging.runSession({
 				idPrefix: "workflows",
 				name: workflowSessionName({
@@ -40507,15 +40880,28 @@ function createWorkflowsWiring({ config, notificationManager, spawnSession, log
 }
 //#endregion
 //#region server/github/github-clock.ts
-function createGithubClock({ baseIntervalMs, setIntervalFn = DEFAULT_TIMER_FNS.setIntervalFn, clearIntervalFn = DEFAULT_TIMER_FNS.clearIntervalFn, log = console }) {
+function createGithubClock({ baseIntervalMs, setIntervalFn = DEFAULT_TIMER_FNS.setIntervalFn, clearIntervalFn = DEFAULT_TIMER_FNS.clearIntervalFn, log = console, githubStatus }) {
 	const subscriptions = /* @__PURE__ */ new Set();
 	let timer = null;
 	let isSweeping = false;
-	let exclusiveChain = Promise.resolve();
-	function exclusive(work) {
-		const outcome = exclusiveChain.then(() => work());
-		exclusiveChain = outcome.catch(() => void 0);
-		return outcome;
+	let isExclusiveRunning = false;
+	const priorityJobs = [];
+	const backgroundJobs = [];
+	function runNextExclusiveJob() {
+		if (isExclusiveRunning) return;
+		const job = priorityJobs.shift() ?? backgroundJobs.shift();
+		if (!job) return;
+		isExclusiveRunning = true;
+		job().finally(() => {
+			isExclusiveRunning = false;
+			runNextExclusiveJob();
+		});
+	}
+	function exclusive(work, { isPriority = false } = {}) {
+		return new Promise((resolve, reject) => {
+			(isPriority ? priorityJobs : backgroundJobs).push(() => Promise.resolve().then(work).then(resolve, reject));
+			runNextExclusiveJob();
+		});
 	}
 	async function sweep() {
 		if (isSweeping) return;
@@ -40557,7 +40943,56 @@ function createGithubClock({ baseIntervalMs, setIntervalFn = DEFAULT_TIMER_FNS.s
 	return {
 		schedule,
 		exclusive,
-		sweep
+		sweep,
+		githubStatus
+	};
+}
+//#endregion
+//#region server/github/core/github-status-core.ts
+var GITHUB_STATUS_CACHE_MS = 3e5;
+var GithubStatusSummary = z.object({ incidents: z.array(z.object({
+	name: z.string(),
+	status: z.string(),
+	updated_at: z.iso.datetime({ offset: true })
+})) });
+function openIncidentName(body) {
+	const summary = GithubStatusSummary.safeParse(body);
+	if (!summary.success) return null;
+	const openIncidents = summary.data.incidents.filter((incident) => incident.status !== "resolved" && incident.status !== "postmortem");
+	openIncidents.sort((first, second) => Date.parse(second.updated_at) - Date.parse(first.updated_at));
+	return openIncidents[0]?.name ?? null;
+}
+function isStatusReadDue(lastReadAtMs, nowMs) {
+	return lastReadAtMs === null || nowMs - lastReadAtMs >= GITHUB_STATUS_CACHE_MS;
+}
+//#endregion
+//#region server/github/github-status.ts
+function createGithubStatus({ fetchFn = fetch, now = Date.now, log }) {
+	let lastReadAtMs = null;
+	let cachedIncident = null;
+	let hasWarned = false;
+	async function readStatus() {
+		try {
+			const response = await fetchFn("https://www.githubstatus.com/api/v2/summary.json", { signal: AbortSignal.timeout(5e3) });
+			if (!response.ok) throw new Error(`HTTP ${response.status}`);
+			cachedIncident = openIncidentName(GithubStatusSummary.parse(await response.json()));
+			hasWarned = false;
+		} catch (error) {
+			cachedIncident = null;
+			if (hasWarned) return;
+			hasWarned = true;
+			log.warn(`[github-status] read failed: ${errorMessage(error)}`);
+		}
+	}
+	function noteTransientFailure() {
+		const nowMs = now();
+		if (!isStatusReadDue(lastReadAtMs, nowMs)) return;
+		lastReadAtMs = nowMs;
+		readStatus();
+	}
+	return {
+		noteTransientFailure,
+		incident: () => cachedIncident
 	};
 }
 //#endregion
@@ -41611,7 +42046,7 @@ function isFresh(fetchedAt, nowMs) {
 	if (!Number.isFinite(fetchedMs)) return false;
 	return nowMs - fetchedMs < CACHE_TTL_MS;
 }
-async function loadPricing({ fetchEnabled, fsPromises = fsp, fetchFn = globalThis.fetch, cachePath = path.join(glimmervoidHomeDir$1(), "litellm-pricing.json"), nowFn = Date.now, timeoutMs = 15e3, logger = null } = {}) {
+async function loadPricing({ fetchEnabled, fsPromises = fs$1, fetchFn = globalThis.fetch, cachePath = path.join(glimmervoidHomeDir$1(), "litellm-pricing.json"), nowFn = Date.now, timeoutMs = 15e3, logger = null } = {}) {
 	if (!fetchEnabled) return {
 		table: normalizePricingTable(claude_pricing_default),
 		source: "snapshot",
@@ -42310,7 +42745,7 @@ async function walkSourceFiles(roots, fsPromises, laneLog) {
 	};
 }
 function createUsageScanner(deps = {}) {
-	const { fsPromises = fsp, env = process.env, homeDir = os.homedir(), nowFn = Date.now, pricingTable, aliases = {}, costMode = "auto", blockHours = 5, retainDays = 90, extraProjectsDirs = [], vendors = {
+	const { fsPromises = fs$1, env = process.env, homeDir = os.homedir(), nowFn = Date.now, pricingTable, aliases = {}, costMode = "auto", blockHours = 5, retainDays = 90, extraProjectsDirs = [], vendors = {
 		codex: true,
 		grok: true
 	}, warehousePath = null, warehouseRetainDays = 365, budget: budgetDep = null, laneMap = null, logger = noopLogger, byteBudget = DEFAULT_BYTE_BUDGET, chunkSize = DEFAULT_CHUNK_SIZE, yieldNowFn = yieldNow } = deps;
@@ -43144,7 +43579,7 @@ function formatBudgetUsd(value) {
 function budgetAlertText({ scope, threshold, spentUsd, budgetUsd }) {
 	return `Usage budget: ${scope === "monthly" ? "monthly" : "daily"} spend ${formatBudgetUsd(spentUsd)} reached ${threshold}% of ${formatBudgetUsd(budgetUsd)}`;
 }
-function createUsageWiring({ config, sessions = /* @__PURE__ */ new Map(), broadcast = () => {}, controlClientCount = () => 0, warehousePath = null, budgetStatePath = null, laneMap = null, telemetry = null, sendTelegram = sendTelegramMessage, telegramTimeoutMs = TELEGRAM_TIMEOUT_MS, fsPromises = fsp, createScanner = createUsageScanner, loadPricingFn = loadPricing, execFileAsync: execFileAsync$1 = execFileAsync, rtkPathFn = defaultRtkPath, scannerDeps = {}, nowFn = Date.now, partialContinueMs = PARTIAL_CONTINUE_MS, setIntervalFn = DEFAULT_TIMER_FNS.setIntervalFn, clearIntervalFn = DEFAULT_TIMER_FNS.clearIntervalFn, setTimeoutFn = DEFAULT_TIMER_FNS.setTimeoutFn, clearTimeoutFn = DEFAULT_TIMER_FNS.clearTimeoutFn, logger = console, debug = false }) {
+function createUsageWiring({ config, sessions = /* @__PURE__ */ new Map(), broadcast = () => {}, controlClientCount = () => 0, warehousePath = null, budgetStatePath = null, laneMap = null, telemetry = null, sendTelegram = sendTelegramMessage, telegramTimeoutMs = TELEGRAM_TIMEOUT_MS, fsPromises = fs$1, createScanner = createUsageScanner, loadPricingFn = loadPricing, execFileAsync: execFileAsync$1 = execFileAsync, rtkPathFn = defaultRtkPath, scannerDeps = {}, nowFn = Date.now, partialContinueMs = PARTIAL_CONTINUE_MS, setIntervalFn = DEFAULT_TIMER_FNS.setIntervalFn, clearIntervalFn = DEFAULT_TIMER_FNS.clearIntervalFn, setTimeoutFn = DEFAULT_TIMER_FNS.setTimeoutFn, clearTimeoutFn = DEFAULT_TIMER_FNS.clearTimeoutFn, logger = console, debug = false }) {
 	const laneLog = createLaneLog({
 		prefix: "[usage]",
 		logger,
@@ -43684,7 +44119,7 @@ function createUsageWiring({ config, sessions = /* @__PURE__ */ new Map(), broad
 }
 //#endregion
 //#region server/usage/usage-lane-ledger.ts
-function createLaneLedger({ ledgerPath = null, fsPromises = fsp, nowFn = Date.now, retainDays = 365, logger = null } = {}) {
+function createLaneLedger({ ledgerPath = null, fsPromises = fs$1, nowFn = Date.now, retainDays = 365, logger = null } = {}) {
 	const laneLog = createLaneLog({
 		prefix: "[usage]",
 		logger
@@ -44716,7 +45151,7 @@ function errorResult(reason, errorSource = ERROR_SOURCE_TRANSPORT) {
 async function readCommentsResult(resultPath, { lineCount = 0, onBytesRead = null } = {}) {
 	let raw = "";
 	try {
-		raw = await fsp.readFile(resultPath, "utf8");
+		raw = await fs$1.readFile(resultPath, "utf8");
 	} catch {
 		return errorResult("no readable result file");
 	}
@@ -44812,11 +45247,11 @@ function createVisionsSpawn({ sessions = /* @__PURE__ */ new Map(), closeSession
 	};
 }
 function makeVisionsWorkDir() {
-	return fsp.mkdtemp(path.join(os.tmpdir(), "glimmervoid-visions-"));
+	return fs$1.mkdtemp(path.join(os.tmpdir(), "glimmervoid-visions-"));
 }
 function createVisionsDispatcher({ spawnSession, timeoutSeconds = 180, model = null, logger = console, nowFn = Date.now, setTimeoutFn = DEFAULT_TIMER_FNS.setTimeoutFn, clearTimeoutFn = DEFAULT_TIMER_FNS.clearTimeoutFn, makeWorkDir = makeVisionsWorkDir, removeWorkDir = async (dir) => {
 	try {
-		await fsp.rm(dir, {
+		await fs$1.rm(dir, {
 			recursive: true,
 			force: true
 		});
@@ -44886,7 +45321,7 @@ function createVisionsDispatcher({ spawnSession, timeoutSeconds = 180, model = n
 			});
 			const sizeDecision = decidePromptSize(generatedPrompt);
 			if (!sizeDecision.dispatch) return errorResult(sizeDecision.gate);
-			await fsp.writeFile(path.join(workDir, PROMPT_FILE), generatedPrompt, "utf8");
+			await fs$1.writeFile(path.join(workDir, PROMPT_FILE), generatedPrompt, "utf8");
 			return await spawnWithTimeout({
 				id: idFor(uri),
 				name: `visions ${uri}`,
@@ -45293,7 +45728,7 @@ function changeFailureReason(uri, version, result) {
 	if (result.reason === "stale-version") return `stale-version (uri=${uri} incoming=${result.version} current=${result.currentVersion})`;
 	return `${result.reason} (uri=${uri} version=${version})`;
 }
-function createVisionsWiring({ debounceMs = 300, setTimeoutFn = DEFAULT_TIMER_FNS.setTimeoutFn, clearTimeoutFn = DEFAULT_TIMER_FNS.clearTimeoutFn, nowFn = Date.now, sweep = sweepMarkdownWithFixes, maxPayload = MAX_FRAME_BYTES, autoFix = false, fixLogMax = 20, applyEditTimeoutMs = APPLY_EDIT_TIMEOUT_MS, logger = console, broadcast = null, dispatchConfig = null, dispatchHistory = [], dispatch = null, contextDigest = null, contextSeq = null, scopeProjects = [], pathsFoldCase = process.platform === "darwin", knownProjectIds = null, onEditorEvent = null, intentStatePath = null, intentThreadTtlMs = DEFAULT_THREAD_TTL_MS, fsFns = fs, fsPromises = fsp, digestBudgetChars = DIGEST_BUDGET_CHARS, hashFn = hashText$1, buildPrompt = buildVisionsPrompt, debug = false } = {}) {
+function createVisionsWiring({ debounceMs = 300, setTimeoutFn = DEFAULT_TIMER_FNS.setTimeoutFn, clearTimeoutFn = DEFAULT_TIMER_FNS.clearTimeoutFn, nowFn = Date.now, sweep = sweepMarkdownWithFixes, maxPayload = MAX_FRAME_BYTES, autoFix = false, fixLogMax = 20, applyEditTimeoutMs = APPLY_EDIT_TIMEOUT_MS, logger = console, broadcast = null, dispatchConfig = null, dispatchHistory = [], dispatch = null, contextDigest = null, contextSeq = null, scopeProjects = [], pathsFoldCase = process.platform === "darwin", knownProjectIds = null, onEditorEvent = null, intentStatePath = null, intentThreadTtlMs = DEFAULT_THREAD_TTL_MS, fsFns = fs, fsPromises = fs$1, digestBudgetChars = DIGEST_BUDGET_CHARS, hashFn = hashText$1, buildPrompt = buildVisionsPrompt, debug = false } = {}) {
 	const wss = new WebSocketServer({
 		noServer: true,
 		maxPayload
@@ -46164,8 +46599,15 @@ function createBackendLanes(dependencies) {
 		warn: (message) => logger.warn(message)
 	});
 	const spawnGate = createSpawnGate({ memoryAdmission });
-	const gitWorkspace = createGitWorkspace({ rerere: config.worktreeRerere !== false });
-	const gitWorkspaceSync = createGitWorkspaceSync();
+	const ownedPaths = createOwnedPathsLedger({
+		filePath: ownedPathsLedgerPath(),
+		log: logger
+	});
+	const gitWorkspace = createGitWorkspace({
+		rerere: config.worktreeRerere !== false,
+		ownedPaths
+	});
+	const gitWorkspaceSync = createGitWorkspaceSync({ ownedPaths });
 	const laneLedger = createLaneLedger({
 		ledgerPath: configSiblingPath(configStore.configPath, "usage-lanes.json"),
 		retainDays: resolveUsageConfig(config.usage).warehouseRetainDays,
@@ -46259,7 +46701,8 @@ function createBackendLanes(dependencies) {
 	});
 	const githubClock = createGithubClock({
 		baseIntervalMs: 6e4,
-		log: logger
+		log: logger,
+		githubStatus: createGithubStatus({ log: logger })
 	});
 	const glimmervoidHome = glimmervoidHomeDir$1();
 	const github = createPrGh(glimmervoidHome);
@@ -46653,6 +47096,7 @@ function createBackendLanes(dependencies) {
 		currentVisions,
 		gitWorkspace,
 		gitWorkspaceSync,
+		ownedPaths,
 		githubStore,
 		investigationSessions,
 		planReview,
@@ -48851,7 +49295,7 @@ var SessionRecorder = class {
 		if (this._retainDays <= 0 && this._retainFiles <= 0 && this._retainBytes <= 0) return;
 		let entries;
 		try {
-			entries = await fsp.readdir(this._baseDir);
+			entries = await fs$1.readdir(this._baseDir);
 		} catch {
 			return;
 		}
@@ -48869,7 +49313,7 @@ var SessionRecorder = class {
 			for (const entry of recordings) {
 				if (doomed.has(entry)) continue;
 				try {
-					if ((await fsp.stat(path.join(this._baseDir, entry))).mtimeMs < cutoff) doomed.add(entry);
+					if ((await fs$1.stat(path.join(this._baseDir, entry))).mtimeMs < cutoff) doomed.add(entry);
 				} catch {}
 			}
 		}
@@ -48877,14 +49321,14 @@ var SessionRecorder = class {
 			const filepath = path.join(this._baseDir, entry);
 			if (filepath === this._filepath || openRecordingPaths.has(filepath)) continue;
 			try {
-				await fsp.unlink(filepath);
+				await fs$1.unlink(filepath);
 			} catch {}
 		}
 		if (this._retainBytes <= 0) return;
 		const current = this._filepath ? path.basename(this._filepath) : null;
 		const measured = (await Promise.all(recordings.filter((entry) => !doomed.has(entry) && entry !== current).map(async (entry) => {
 			try {
-				const stat = await fsp.stat(path.join(this._baseDir, entry));
+				const stat = await fs$1.stat(path.join(this._baseDir, entry));
 				return {
 					entry,
 					size: stat.size,
@@ -48899,7 +49343,7 @@ var SessionRecorder = class {
 		for (const entry of evictable) {
 			if (totalBytes <= this._retainBytes) return;
 			try {
-				await fsp.unlink(path.join(this._baseDir, entry.entry));
+				await fs$1.unlink(path.join(this._baseDir, entry.entry));
 				totalBytes -= entry.size;
 			} catch (err) {
 				if (isMissingFileError(err, { includeNotDir: false })) totalBytes -= entry.size;
@@ -49027,6 +49471,8 @@ function createSessionFactory(dependencies) {
 			isSettingOn: (dependencies.getConfig?.() ?? config).coherence?.enabled === true
 		});
 		const builtMapping = project.environment;
+		const sessionTempFolder = builtMapping ? null : sessionTempFolderFor(project.id);
+		if (sessionTempFolder) fs.mkdirSync(sessionTempFolder, { recursive: true });
 		const session = new Session({
 			id: project.id,
 			name: project.name,
@@ -49064,6 +49510,10 @@ function createSessionFactory(dependencies) {
 			commitSigningProgram: dependencies.commitSigningProgram ?? null,
 			getRemoteLaunch: builtMapping ? () => remoteLaunchFor(project, builtMapping, dependencies.getConfig?.() ?? config) : null,
 			...overrides,
+			spawnEnv: sessionTempFolder ? {
+				CLAUDE_CODE_TMPDIR: sessionTempFolder,
+				...overrides.spawnEnv ?? {}
+			} : overrides.spawnEnv,
 			prepareGuardrails: "prepareGuardrails" in overrides ? overrides.prepareGuardrails : defaultGuardrailsFor(project, config, overrides)
 		});
 		const captureConfig = {
@@ -50923,22 +51373,37 @@ function registerControlHandlers(controlWss, deps) {
 			console.log(`[control] Removed spawned session via UI: ${sess.name}`);
 			return { ok: true };
 		}
+		const isDiscardingWorkspaceWork = sess.isWorkspace && msg.discardWork === true;
+		if (isDiscardingWorkspaceWork) sess.killSession();
+		const keptPaths = sess.isWorkspace ? await sess.findWorkspaceKeptWork() : [];
+		const confirmedKeptPaths = new Set(isDiscardingWorkspaceWork ? msg.confirmedKeptPaths ?? [] : []);
+		if (keptPaths.some((kept) => !confirmedKeptPaths.has(kept.path))) return {
+			ok: false,
+			error: "Workspace members hold work that is not saved",
+			canDiscardWork: true,
+			keptPaths
+		};
 		if (config.projects.some((project) => project.id === sess.id && project.environment) && coderEnv) {
 			sess.killSession();
 			const settlement = await coderEnv.settleRemoval({
 				projectId: sess.id,
-				discardRemoteWork: msg.discardRemoteWork === true
+				discardRemoteWork: msg.discardWork === true
 			});
 			if (!settlement.ok) return {
 				ok: false,
 				error: settlement.reason,
-				canDiscardRemoteWork: settlement.canDiscardRemoteWork
+				canDiscardWork: settlement.canDiscardRemoteWork
 			};
 		}
 		const freshConfig = configStore.save((cfg) => {
 			cfg.projects = cfg.projects.filter((p) => p.id !== sess.id);
 		});
-		if (freshConfig) applyConfigReload(freshConfig);
+		if (!freshConfig) return {
+			ok: false,
+			error: `Could not save the removal of session "${sess.name}"`
+		};
+		if (isDiscardingWorkspaceWork) sess.confirmWorkspaceWorkDiscard();
+		applyConfigReload(freshConfig);
 		console.log(`[control] Removed session via UI: ${sess.name}`);
 		return { ok: true };
 	}
@@ -53799,7 +54264,7 @@ async function downloadCapped(url, { fetchImpl, timeoutMs = DOWNLOAD_TIMEOUT_MS
 	}
 }
 async function findBinary(dir, platform) {
-	const entries = await fsp.readdir(dir, { withFileTypes: true });
+	const entries = await fs$1.readdir(dir, { withFileTypes: true });
 	const nested = [];
 	for (const entry of entries) {
 		const full = path.join(dir, entry.name);
@@ -53817,13 +54282,13 @@ async function findBinary(dir, platform) {
 }
 async function removeQuietly(target) {
 	try {
-		await fsp.rm(target, {
+		await fs$1.rm(target, {
 			recursive: true,
 			force: true
 		});
 	} catch {}
 }
-async function moveIntoPlace(source, target, renameImpl = fsp.rename) {
+async function moveIntoPlace(source, target, renameImpl = fs$1.rename) {
 	try {
 		await renameImpl(source, target);
 		return;
@@ -53832,15 +54297,15 @@ async function moveIntoPlace(source, target, renameImpl = fsp.rename) {
 	}
 	const partial = `${target}.partial`;
 	try {
-		await fsp.copyFile(source, partial);
+		await fs$1.copyFile(source, partial);
 		await renameImpl(partial, target);
 	} catch (err) {
 		await removeQuietly(partial);
 		throw err;
 	}
-	await fsp.unlink(source);
+	await fs$1.unlink(source);
 }
-async function installRtk({ homeDir = os.homedir(), glimmervoidHome = glimmervoidHomeDir(homeDir, process.env), platform = process.platform, arch = process.arch, fetchImpl = globalThis.fetch, execFileImpl = execFileAsync, renameImpl = fsp.rename, timeoutMs = DOWNLOAD_TIMEOUT_MS, log = console, asset = assetForPlatform(platform, arch) } = {}) {
+async function installRtk({ homeDir = os.homedir(), glimmervoidHome = glimmervoidHomeDir(homeDir, process.env), platform = process.platform, arch = process.arch, fetchImpl = globalThis.fetch, execFileImpl = execFileAsync, renameImpl = fs$1.rename, timeoutMs = DOWNLOAD_TIMEOUT_MS, log = console, asset = assetForPlatform(platform, arch) } = {}) {
 	if (!asset) return {
 		ok: false,
 		reason: `unsupported platform ${platform}-${arch}`
@@ -53851,7 +54316,7 @@ async function installRtk({ homeDir = os.homedir(), glimmervoidHome = glimmervoi
 	};
 	const stagingDir = path.join(glimmervoidHome, "tmp", `rtk-${crypto.randomBytes(6).toString("hex")}`);
 	try {
-		await fsp.mkdir(stagingDir, { recursive: true });
+		await fs$1.mkdir(stagingDir, { recursive: true });
 	} catch (err) {
 		return {
 			ok: false,
@@ -53874,9 +54339,9 @@ async function installRtk({ homeDir = os.homedir(), glimmervoidHome = glimmervoi
 			reason: `sha256 mismatch for ${asset.file}: expected ${asset.sha256}, got ${actualHex}`
 		};
 		const archivePath = path.join(stagingDir, asset.file);
-		await fsp.writeFile(archivePath, downloaded.bytes);
+		await fs$1.writeFile(archivePath, downloaded.bytes);
 		const extractDir = path.join(stagingDir, "extract");
-		await fsp.mkdir(extractDir, { recursive: true });
+		await fs$1.mkdir(extractDir, { recursive: true });
 		try {
 			const listing = await execFileImpl("tar", ["-tf", archivePath]);
 			const escaping = findEscapingArchiveMember(listing.stdout);
@@ -53901,13 +54366,13 @@ async function installRtk({ homeDir = os.homedir(), glimmervoidHome = glimmervoi
 			ok: false,
 			reason: `extract failed: no rtk binary inside ${asset.file}`
 		};
-		if (!(await fsp.lstat(extracted)).isFile()) return {
+		if (!(await fs$1.lstat(extracted)).isFile()) return {
 			ok: false,
 			reason: `extract failed: rtk inside ${asset.file} is not a regular file`
 		};
-		if (platform !== "win32") await fsp.chmod(extracted, 493);
+		if (platform !== "win32") await fs$1.chmod(extracted, 493);
 		const target = installTargetPath(glimmervoidHome, platform);
-		await fsp.mkdir(path.dirname(target), { recursive: true });
+		await fs$1.mkdir(path.dirname(target), { recursive: true });
 		await removeQuietly(target);
 		await moveIntoPlace(extracted, target, renameImpl);
 		log?.log?.(`[rtk] installed rtk ${asset.version} at ${target}`);
@@ -53998,13 +54463,13 @@ function sleepFor(durationMs) {
 function createClaudeFolderTrust({ env = process.env, homeDir = os.homedir(), now = Date.now, platform = process.platform, sleep = sleepFor } = {}) {
 	async function resolveConfiguredPath() {
 		const [legacyConfigPath, currentConfigPath] = listClaudeGlobalConfigPathCandidates(env, homeDir);
-		return await fsp.access(legacyConfigPath).then(() => true, () => false) ? legacyConfigPath : currentConfigPath;
+		return await fs$1.access(legacyConfigPath).then(() => true, () => false) ? legacyConfigPath : currentConfigPath;
 	}
 	function refusal(repositoryRoot, configPath, reason) {
 		return /* @__PURE__ */ new Error(`Could not trust ${repositoryRoot} for Claude Code: ${configPath} was left unchanged because ${reason}`);
 	}
 	async function readTrustDecision(repositoryRoot, configPath) {
-		const decision = decideFolderTrust(await fsp.readFile(configPath, "utf8").catch((error) => {
+		const decision = decideFolderTrust(await fs$1.readFile(configPath, "utf8").catch((error) => {
 			throw refusal(repositoryRoot, configPath, `it could not be read (${errorCode(error) ?? "unknown error"})`);
 		}), repositoryRoot, platform);
 		if (decision.kind === "unreadable") throw refusal(repositoryRoot, configPath, decision.reason);
@@ -54012,13 +54477,13 @@ function createClaudeFolderTrust({ env = process.env, homeDir = os.homedir(), no
 	}
 	async function tryTakeConfigLock(lockPath) {
 		try {
-			await fsp.mkdir(lockPath);
+			await fs$1.mkdir(lockPath);
 			return true;
 		} catch (error) {
 			if (errorCode(error) !== "EEXIST") throw error;
 		}
-		const heldLock = await fsp.stat(lockPath).catch(() => null);
-		if (heldLock && isConfigLockStale(heldLock.mtimeMs, now())) await fsp.rmdir(lockPath).catch(() => {});
+		const heldLock = await fs$1.stat(lockPath).catch(() => null);
+		if (heldLock && isConfigLockStale(heldLock.mtimeMs, now())) await fs$1.rmdir(lockPath).catch(() => {});
 		return false;
 	}
 	async function takeConfigLock(repositoryRoot, configuredPath) {
@@ -54031,17 +54496,17 @@ function createClaudeFolderTrust({ env = process.env, homeDir = os.homedir(), no
 	}
 	async function ensureTrusted(repositoryRoot) {
 		const configuredPath = await resolveConfiguredPath();
-		const configPath = await fsp.realpath(configuredPath).catch(() => configuredPath);
+		const configPath = await fs$1.realpath(configuredPath).catch(() => configuredPath);
 		if ((await readTrustDecision(repositoryRoot, configPath)).kind === "trusted") return "already-trusted";
 		const lockPath = await takeConfigLock(repositoryRoot, configuredPath);
 		try {
 			const decision = await readTrustDecision(repositoryRoot, configPath);
 			if (decision.kind === "trusted") return "already-trusted";
-			const { mode } = await fsp.stat(configPath);
+			const { mode } = await fs$1.stat(configPath);
 			await writeTextAtomic(configPath, decision.nextConfigText, { mode: mode & 511 });
 			return "granted";
 		} finally {
-			await fsp.rmdir(lockPath).catch(() => {});
+			await fs$1.rmdir(lockPath).catch(() => {});
 		}
 	}
 	return { ensureTrusted };
@@ -54283,11 +54748,11 @@ function spawnConnectPty(file, args, options) {
 	return pty.spawn(file, args, options);
 }
 async function makePrivateDir(directory) {
-	await fsp.mkdir(directory, {
+	await fs$1.mkdir(directory, {
 		recursive: true,
 		mode: 448
 	});
-	await fsp.chmod(directory, 448);
+	await fs$1.chmod(directory, 448);
 }
 function createAgentConnect({ loginsRoot, loginSource, launchFor, onChange, ptySpawn = spawnConnectPty, makeHomeDir = makePrivateDir, setTimeoutFn = setTimeout, clearTimeoutFn = clearTimeout }) {
 	const statusByAgent = new Map(CONNECTABLE_AGENTS.map((agent) => [agent, idleLoginStatus(agent, null)]));
@@ -54492,7 +54957,7 @@ function chatgptAuthTokensRefreshResult(login) {
 //#region server/codex-credentials.ts
 var HOST_REFRESH_TIMEOUT_MS = 6e4;
 async function readTextFileOrNull(filePath) {
-	return fsp.readFile(filePath, "utf8").catch(() => null);
+	return fs$1.readFile(filePath, "utf8").catch(() => null);
 }
 function codexHomeDir(env, homeDir) {
 	const override = env.CODEX_HOME?.trim();
@@ -55101,7 +55566,8 @@ function createUpdateApplyLane(dependencies) {
 			await runWorkspaceStep("stage", () => dependencies.gitWorkspace.stageDetachedWorktree({
 				projectPath: dependencies.packageRoot,
 				worktreePath: stagingPath,
-				sha: status.latestSha || void 0
+				sha: status.latestSha || void 0,
+				owner: "lane:update-apply"
 			}));
 			const lockfileDiff = await gitCommand([
 				"diff",
@@ -55472,19 +55938,19 @@ async function collectWorktreePaths(projects) {
 }
 async function readFileNames(folder) {
 	try {
-		return (await fsp.readdir(folder, { withFileTypes: true })).filter((entry) => entry.isFile()).map((entry) => entry.name);
+		return (await fs$1.readdir(folder, { withFileTypes: true })).filter((entry) => entry.isFile()).map((entry) => entry.name);
 	} catch (error) {
 		if (isMissingFileError(error)) return null;
 		throw error;
 	}
 }
 async function removeFolderIfEmpty(folder) {
-	if ((await fsp.readdir(folder)).length > 0) return;
-	await fsp.rmdir(folder);
+	if ((await fs$1.readdir(folder)).length > 0) return;
+	await fs$1.rmdir(folder);
 }
 async function isRealDirectory(folder) {
 	try {
-		return (await fsp.lstat(folder)).isDirectory();
+		return (await fs$1.lstat(folder)).isDirectory();
 	} catch (error) {
 		if (isMissingFileError(error)) return false;
 		throw error;
@@ -55492,10 +55958,10 @@ async function isRealDirectory(folder) {
 }
 async function isReportFolderOwnedByWorktree(worktreePath, reportFolder) {
 	if (!await isRealDirectory(path.dirname(reportFolder)) || !await isRealDirectory(reportFolder)) return false;
-	const realWorktreePath = await fsp.realpath(worktreePath);
-	if (!isPathInside(realWorktreePath, await fsp.realpath(reportFolder), { allowEqual: false })) return false;
+	const realWorktreePath = await fs$1.realpath(worktreePath);
+	if (!isPathInside(realWorktreePath, await fs$1.realpath(reportFolder), { allowEqual: false })) return false;
 	const reportFolderTopLevel = (await gitOutput(["rev-parse", "--show-toplevel"], reportFolder)).trim();
-	return equalsIgnoringCaseOnWindows(await fsp.realpath(reportFolderTopLevel), realWorktreePath);
+	return equalsIgnoringCaseOnWindows(await fs$1.realpath(reportFolderTopLevel), realWorktreePath);
 }
 async function listTrackedReportGitPaths(worktreePath) {
 	return (await gitOutput([
@@ -55512,7 +55978,7 @@ async function cleanWorktree(worktreePath) {
 	if (fileNames === null) return NOTHING_CLEANED;
 	const trackedReportGitPaths = await listTrackedReportGitPaths(worktreePath);
 	const deletableFileNames = untrackedReportFileNames(fileNames, trackedReportGitPaths);
-	for (const fileName of deletableFileNames) await fsp.rm(path.join(reportFolder, fileName), { force: true });
+	for (const fileName of deletableFileNames) await fs$1.rm(path.join(reportFolder, fileName), { force: true });
 	await removeFolderIfEmpty(reportFolder);
 	await removeFolderIfEmpty(path.dirname(reportFolder));
 	return {
@@ -56566,6 +57032,12 @@ function createBackend(httpServer, options = {}) {
 	const reconcileProjectsOnReload = sessionRegistry.applyConfigReload;
 	rtkInstall.maybeInstall();
 	sweepOrphanedGuardrailsLaunches();
+	reconcileOwnedPaths({
+		ledger: laneAssembly.ownedPaths,
+		configuredSessionIds: new Set(config.projects.map((project) => project.id)),
+		git: laneAssembly.gitWorkspace,
+		shareList: config.worktreeShare || DEFAULT_CONFIG.worktreeShare
+	});
 	laneAssembly.startRuntimeLanes();
 	function applyCustomAgents(sourceConfig) {
 		setCustomAgents(sourceConfig.customAgents ?? []);