@dylanpiercey/work 0.2.71 → 0.2.72

package/dist/{_DHaRHB4s.js → _Ckb53sPe.js}

@@ -9674,7 +9674,7 @@ function publishChange(sessionId) {
 	const row = get("SELECT workspace_id FROM sessions WHERE id = ?", sessionId);
 	if (row?.workspace_id) {
 		const workspaceId = row.workspace_id;
-		import("./_BawMVLA9.js").then((m) => m.notifySessionsChanged(workspaceId));
+		import("./_BA1HQgf_.js").then((m) => m.notifySessionsChanged(workspaceId));
 		return;
 	}
 	publish("sessions.changed");
@@ -11910,7 +11910,8 @@ onPhaseChange(() => {
 });
 /** Whether files under `dir` may have changed since `since` (ms): an agent
 * of its workspace working now, or anything noted there since. A directory
-* outside every workspace may have, always. */
+* outside every workspace may have, always. Per workspace, not per folder,
+* by choice: an agent writes wherever it `cd`s, which nothing here sees. */
 function activeSince(dir, since) {
 	const id = workspaceAt(dir);
 	if (!id) return true;
@@ -11937,7 +11938,14 @@ function workspaceAt(dir) {
 * each its own process. Kept by size, the least recently used going
 * first; a failure is never kept (the object may simply not be here
 * yet). */
-var MAX_BYTES = 134217728;
+var MiB = 1048576;
+/** A thirty-second of the machine's memory, between 128 MiB and 1 GiB. A
+* load asks for every section's files in turn, so one workspace whose
+* patches outgrow the cap pushed each out before the next load came back
+* for it: a fixed 128 MiB held none of a workspace of ~240 MiB, and every
+* load took the whole diff again (ten seconds). The text is mostly what
+* the kept diffs hold anyway. */
+var MAX_BYTES = Math.min(1024 * MiB, Math.max(128 * MiB, Math.floor(os.totalmem() / 32)));
 var kept = /* @__PURE__ */ new Map();
 var total = 0;
 var SHA = /^[0-9a-f]{40,64}$/;
@@ -12288,7 +12296,8 @@ function sectionFor(list, id) {
 * agent's `git fetch`, in the shared cache, and a commit on a lane in its
 * own worktree. PR heads are the status watcher's. The diff route answers
 * an unchanged stamp with the diff it last took (`workspaceDiff`). */
-async function diffStamp(ws) {
+async function diffStamp(ws, only) {
+	if (only) return sectionStamp(ws, only);
 	const parts = await Promise.all(ws.repos.map(async (repo) => {
 		const dir = path.join(ws.path, repo.worktree);
 		let out;
@@ -12314,13 +12323,36 @@ async function diffStamp(ws) {
 		} catch {
 			return `${repo.worktree}\0-`;
 		}
-		const stats = await Promise.all(changedPaths(out).map((p) => fs$1.lstat(path.join(dir, p)).then((st) => `${st.size}:${st.mtimeMs}`, () => "-")));
-		return `${repo.worktree}\0${head}\0${out}\0${refs}\0${stats.join(",")}`;
+		const stats = await statsOf(dir, out);
+		return `${repo.worktree}\0${head}\0${out}\0${refs}\0${stats}`;
 	}));
 	const hash = createHash("sha1");
 	for (const part of parts) hash.update(part).update("\n");
 	return hash.digest("base64url");
 }
+/** One section's stamp (`SectionScope`): its own refs, and the status of
+* the checkout or worktree its edits are read from. A review showing one
+* topic stamped the whole workspace, so another topic's agent at work
+* held it back behind a Refresh for a change it would not show. */
+async function sectionStamp(ws, only) {
+	const dir = path.join(ws.path, only.worktree);
+	const [refs, head, out] = await Promise.all([
+		git([
+			"for-each-ref",
+			"--format=%(refname) %(objectname)",
+			...only.refs
+		], dir).catch(() => ""),
+		headOid(dir).then((h) => only.checkout ? `${h.branch} ${h.oid}` : h.branch, () => ""),
+		only.edits ? statusOf(only.edits).catch(() => "") : ""
+	]);
+	const stats = only.edits ? await statsOf(only.edits, out) : "";
+	return createHash("sha1").update(`${only.id}\0${head}\0${refs}\0${out}\0${stats}`).digest("base64url");
+}
+/** The size and mtime of each path `git status` listed: a file already
+* modified stays "M" however often it is edited again. */
+async function statsOf(dir, status) {
+	return (await Promise.all(changedPaths(status).map((p) => fs$1.lstat(path.join(dir, p)).then((st) => `${st.size}:${st.mtimeMs}`, () => "-")))).join(",");
+}
 /** Each checkout's last `git status`, and when it was begun. The status
 * is most of a stamp's cost (a large repo's untracked files walked, every
 * few seconds while a review is on screen), and it can only have moved if
@@ -13316,9 +13348,44 @@ async function treeContainedInUncached(dir, base, head, baseTree) {
 * the new stamp over the old diff and never reloads it. */
 var diffInFlight = /* @__PURE__ */ new Map();
 function workspaceDiff(ws, stamp, opts = {}) {
-	const { sinceReview, ...listed } = opts;
+	const { sinceReview, only, ...listed } = opts;
 	const since = !!sinceReview && !opts.rev && opts.scope !== "dirty";
-	return listedDiff(ws, stamp, listed).then((sections) => withReview(ws, sections, since));
+	return listedDiff(ws, stamp, {
+		...listed,
+		only: only?.id
+	}).then((sections) => withReview(ws, sections, since));
+}
+/** The section `pick` names, as one to show alone (`SectionScope`); null
+* where it names none the strip would list (client branch-state
+* `inStrip`), which the review then shows with every other. Read from the
+* one repo's section listing (`repoSectionList`, kept by its refs), so a
+* stamp asked every few seconds costs no more than its own repo's. */
+async function sectionScope(ws, pick) {
+	const worktree = pick.split(/[@#]/)[0];
+	const repo = ws.repos.find((r) => r.worktree === worktree);
+	if (!repo) return null;
+	const { dir, list } = await repoSectionList(ws, repo, otherWorkspaceBranches(ws.id));
+	const id = sectionFor(list, pick);
+	const s = id ? list.find((x) => x.id === id) : void 0;
+	if (!id || !s) return null;
+	const head = s.pr?.headRefName ?? s.headRef ?? s.branch;
+	const checkout = head === s.branch;
+	const edits = checkout ? dir : (await laneWorktrees(dir)).get(head);
+	if (!s.pr && s.contained && !(edits && await editsOf(edits))) return null;
+	const own = [head, s.parent].filter((b) => !!b);
+	const bases = [
+		s.pr?.baseRefName,
+		repo.base_branch,
+		repo.default_branch
+	];
+	const refs = [...own.flatMap((b) => [`refs/heads/${b}`, `refs/remotes/origin/${b}`]), ...bases.flatMap((b) => b ? [`refs/remotes/origin/${b}`] : [])];
+	return {
+		id,
+		worktree,
+		refs: [...new Set(refs)],
+		checkout,
+		...edits && { edits }
+	};
 }
 function listedDiff(ws, stamp, opts) {
 	const { refresh, ...asked } = opts;
@@ -13336,7 +13403,7 @@ function listedDiff(ws, stamp, opts) {
 	if (running) return running;
 	const last = diffKept.get(which);
 	if (last && !refresh && last.stamp === stamp && Date.now() - last.at < DIFF_KEEP_MS) return last.sections;
-	const run = computeWorkspaceDiff(ws, opts).finally(() => {
+	const run = (opts.only ? scopedDiff(ws, opts, opts.only) : computeWorkspaceDiff(ws, opts)).finally(() => {
 		diffInFlight.delete(key);
 	});
 	diffInFlight.set(key, run);
@@ -13352,6 +13419,35 @@ function listedDiff(ws, stamp, opts) {
 	});
 	return run;
 }
+/** One section's diff (`only`), with every other section the review
+* names listed beside it without its files (`workspaceSections`, the
+* listing Files' strip reads), so the strip and its picks stay whole. A
+* workspace of eighty topics took ten seconds and sent ninety megabytes
+* for a review showing one of them. */
+async function scopedDiff(ws, opts, only) {
+	const [own, listing] = await Promise.all([computeWorkspaceDiff(ws, opts), workspaceSections(ws)]);
+	const got = own.find((s) => s.id === only);
+	if (!got) return computeWorkspaceDiff(ws, {
+		...opts,
+		only: void 0
+	});
+	const out = listing.map((s) => {
+		if (s.id === only) {
+			const { nextToLand, ...rest } = got;
+			return {
+				...rest,
+				...s.nextToLand && { nextToLand: true }
+			};
+		}
+		return {
+			...s,
+			topic: topicOf(s, ws.branch),
+			omitted: true
+		};
+	});
+	if (!listing.some((s) => s.id === only)) out.push(got);
+	return out;
+}
 /** How long a workspace's last diff answers for an unchanged stamp, and
 * how many are kept (a workspace's scopes and one-commit views). */
 var DIFF_KEEP_MS = 6e4;
@@ -13379,9 +13475,9 @@ function withReview(ws, sections, since) {
 		const reviewed = {
 			...s,
 			reviewed: point.at,
-			...point.snap === s.snap && { upToDate: true }
+			...s.snap && point.snap === s.snap && { upToDate: true }
 		};
-		return since ? sinceReviewed(ws, reviewed, point.snap) : reviewed;
+		return since && !s.omitted ? sinceReviewed(ws, reviewed, point.snap) : reviewed;
 	}));
 	kept.clear();
 	kept.set(key, run);
@@ -13501,10 +13597,11 @@ async function replayed(dir, snap, against) {
 	});
 }
 async function computeWorkspaceDiff(ws, opts = {}) {
-	const { baseRef, scope = "committed", pr: focus, refresh = false, rev } = opts;
+	const { baseRef, scope = "committed", pr: focus, refresh = false, rev, only } = opts;
 	if (refresh) for (const repo of ws.repos) lastFetch.delete(repo.full_name);
 	const foreign = otherWorkspaceBranches(ws.id);
-	return (await Promise.all(ws.repos.map(async (repo) => {
+	const repos = only ? ws.repos.filter((r) => r.worktree === only.split(/[@#]/)[0]) : ws.repos;
+	return (await Promise.all(repos.map(async (repo) => {
 		const dir = path.join(ws.path, repo.worktree);
 		const [{ oid: localHead, branch }, prs] = await Promise.all([headOid(dir), workspacePrs(repo.full_name, ws.branch, foreign, refresh, ws.imported_at)]);
 		const merged = mergedTips(prs);
@@ -13530,19 +13627,24 @@ async function computeWorkspaceDiff(ws, opts = {}) {
 			], ws.id, refresh);
 			const tips = refresh ? await familyBranches(dir, ws, foreign) : found;
 			const [places, trees] = await Promise.all([stackParents(dir, ws, repo, tips, open), laneWorktrees(dir)]);
+			const wanted = (id) => !only || id === only;
+			const prId = (p) => `${repo.worktree}#${p.number}`;
 			const jobs = tips.names.flatMap((name) => {
 				const prs = open.filter((p) => p.headRefName === name);
-				if (prs.length) return prs.map((p) => () => pr(p));
+				if (prs.length) return prs.filter((p) => wanted(prId(p))).map((p) => () => pr(p));
+				const id = sectionId(repo.worktree, name, ws.branch);
+				if (!wanted(id)) return [];
 				const parent = places.get(name)?.parent;
-				if (name === branch) return [() => local(sectionId(repo.worktree, name, ws.branch), parent)];
+				if (name === branch) return [() => local(id, parent)];
 				return [() => branchDiff(dir, ws, repo, name, branch, foreign, scope, rev, parent, trees.get(name), merged)];
 			});
-			for (const p of open) if (!tips.names.includes(p.headRefName)) jobs.push(() => pr(p));
+			for (const p of open) if (!tips.names.includes(p.headRefName) && wanted(prId(p))) jobs.push(() => pr(p));
 			list = placeInStacks((await Promise.all(jobs.map((job) => job()))).filter((s) => !!s), tips.names, places, ws.branch, repo.base_branch);
 			await markEdits(list, trees, dir, () => editsLanded(ws.id));
 		} else if (open.length) list = await Promise.all(open.map(pr));
 		else if (focus) list = [];
 		else list = [await local()];
+		if (only) list = list.filter((s) => s.id === only);
 		for (const s of list) s.topic = topicOf(s, ws.branch);
 		if (family.length) await Promise.all(list.map((s) => markPushed(dir, s)));
 		return list;
@@ -14748,47 +14850,111 @@ async function readBlobAt(dir, rev, filePath) {
 		proc.on("close", (code) => resolve(over || code !== 0 ? null : Buffer.concat(chunks)));
 	});
 }
-/** `sections` as a response under `budget` characters of patch text: past
-* it, the largest patches are left out (`deferred`, a hash of each to know
-* it by) until the rest fit. A workspace of many topics over a large repo
-* sent tens of megabytes, which a phone's tab could not hold: iOS killed
-* it, reloaded it into the same request, and gave up. Small files stay
-* whole, so most of a review reads as it did; the page fetches a large
-* one as it comes on screen. The same sections at the same budget come
-* back as the same object, for the route's hash. */
-function withinBudget(sections, budget) {
+/** `sections` as a response under `budget` characters of patch text.
+* Past it each topic gets an even share — what a small topic leaves
+* unused going to the larger ones — and a topic over its share leaves
+* out its largest patches (`deferred`, a hash of each to know it by) until
+* the rest fit. A workspace of many topics over a large repo sent tens of
+* megabytes, which a phone's tab could not hold: iOS killed it, reloaded
+* it into the same request, and gave up. One cut across the whole review
+* let a few topics that regenerate thousands of snapshots push every file
+* over a kilobyte out of every other topic, a topic of 23 files included;
+* shared out, a small topic reads whole however large its neighbours are.
+* The page fetches a left-out file as it comes on screen, by its hash
+* (`deferredPatch`, kept here for `wsId`). The same sections at the same
+* budget come back as the same object, for the route's hash. */
+function withinBudget(sections, budget, wsId) {
 	let byBudget = budgeted.get(sections);
 	if (!byBudget) budgeted.set(sections, byBudget = /* @__PURE__ */ new Map());
-	const kept = byBudget.get(budget);
-	if (kept) return kept;
-	const sizes = sections.flatMap((s) => s.files.flatMap((f) => f.patch ? [f.patch.length] : []));
-	let total = sizes.reduce((a, n) => a + n, 0);
-	let out = sections;
-	if (total > budget) {
-		sizes.sort((a, b) => b - a);
+	let kept = byBudget.get(budget);
+	if (!kept) {
+		kept = cutToBudget(sections, budget);
+		byBudget.set(budget, kept);
+	}
+	if (kept.deferred.size) holdDeferred(wsId, kept.deferred);
+	return kept.out;
+}
+var budgeted = /* @__PURE__ */ new WeakMap();
+function cutToBudget(sections, budget) {
+	const deferred = /* @__PURE__ */ new Map();
+	const keyOf = (s) => s.topic ?? s.id;
+	const totals = /* @__PURE__ */ new Map();
+	let total = 0;
+	for (const s of sections) for (const f of s.files) {
+		const n = f.patch?.length ?? 0;
+		totals.set(keyOf(s), (totals.get(keyOf(s)) ?? 0) + n);
+		total += n;
+	}
+	if (total <= budget) return {
+		out: sections,
+		deferred
+	};
+	const sizes = [...totals.values()].sort((a, b) => a - b);
+	let left = budget;
+	let share = 0;
+	for (let i = 0; i < sizes.length; i++) {
+		const even = left / (sizes.length - i);
+		if (sizes[i] > even) {
+			share = even;
+			break;
+		}
+		left -= sizes[i];
+	}
+	const cuts = /* @__PURE__ */ new Map();
+	for (const [topic, size] of totals) {
+		if (size <= share) continue;
+		const lengths = sections.filter((s) => keyOf(s) === topic).flatMap((s) => s.files.flatMap((f) => f.patch ? [f.patch.length] : [])).sort((a, b) => b - a);
+		let kept = size;
 		let cut = Infinity;
-		for (const n of sizes) {
-			if (total <= budget) break;
-			total -= n;
+		for (const n of lengths) {
+			if (kept <= share) break;
+			kept -= n;
 			cut = n;
 		}
-		out = sections.map((s) => ({
-			...s,
-			files: s.files.map((f) => {
-				if (!f.patch || f.patch.length < cut) return f;
-				const { patch, ...rest } = f;
-				return {
-					...rest,
-					deferred: true,
-					patchHash: createHash("sha1").update(patch).digest("base64url")
-				};
-			})
-		}));
+		cuts.set(topic, cut);
+	}
+	return {
+		out: sections.map((s) => {
+			const cut = cuts.get(keyOf(s));
+			if (cut === void 0) return s;
+			return {
+				...s,
+				files: s.files.map((f) => {
+					if (!f.patch || f.patch.length < cut) return f;
+					const { patch, ...rest } = f;
+					const patchHash = createHash("sha1").update(patch).digest("base64url");
+					deferred.set(patchHash, patch);
+					return {
+						...rest,
+						deferred: true,
+						patchHash
+					};
+				})
+			};
+		}),
+		deferred
+	};
+}
+/** Each workspace's last few responses' left-out patches, newest first
+* (New and Diff, a phone's budget and a desktop's): a page asking for one
+* as it comes on screen is answered from here by its hash, with no stamp
+* taken and no diff looked up — a diff kept past its minute was taken
+* again whole for one file, ten seconds on a workspace of many topics.
+* The text is the kept diffs' own, not a copy. */
+var deferredHeld = /* @__PURE__ */ new Map();
+var DEFERRED_HELD = 4;
+function holdDeferred(wsId, patches) {
+	const list = (deferredHeld.get(wsId) ?? []).filter((m) => m !== patches);
+	list.unshift(patches);
+	deferredHeld.set(wsId, list.slice(0, DEFERRED_HELD));
+}
+/** A patch a response to `wsId` left out, by its hash (`withinBudget`). */
+function deferredPatch(wsId, hash) {
+	for (const patches of deferredHeld.get(wsId) ?? []) {
+		const patch = patches.get(hash);
+		if (patch !== void 0) return patch;
 	}
-	byBudget.set(budget, out);
-	return out;
 }
-var budgeted = /* @__PURE__ */ new WeakMap();
 /** One file's patch in `sections`, for a page that was sent it deferred. */
 function patchIn(sections, section, file) {
 	return sections.find((s) => s.id === section)?.files.find((f) => f.path === file)?.patch;
@@ -18198,7 +18364,7 @@ function notifySessionsChanged(workspaceId) {
 async function emitSessionsChanged(workspaceId) {
 	try {
 		const states = await sessionStates();
-		const { teamsOf } = await import("./_D3ixWlKr.js");
+		const { teamsOf } = await import("./_CfUEaP2Y.js");
 		publish("sessions.changed", {
 			workspaceId,
 			sessions: listSessions(workspaceId).map((s) => ({
@@ -20230,4 +20396,4 @@ ${repoLines}
 `;
 }
 //#endregion
-export { ownWorkspaceOnly as $, setScrapedPhase as $n, miseInstalls as $r, readFileAt as $t, clearTmuxStarted as A, tmux as Ai, realInside as An, ensureGitCredentials as Ar, allServers as At, interruptSession as B, noteInterrupt as Bn, changePref as Br, whileInstalling as Bt, workspaceBranches as C, get as Ci, steerKeys as Cn, pendingSsoOrgs as Cr, lspQueryOf as Ct, agentCaller as D, SCRATCH_TMUX as Di, writeCache as Dn, DEFAULT_HOST as Dr, stopAllServers as Dt, hookToken as E, ensureAllCacheConfig as Ei, readCache as En, repoDefaultBranch as Er, runningServers as Et, descendantsOf as F, hookReportedAt as Fn, unreachableRepos as Fr, lspEnabled as Ft, listPanesWithin as G, notifyEventOn as Gn, isKnownAgent as Gr, logoutGithub as Gt, killWorkspaceSessions as H, noteTurnFailed as Hn, disabledAgents as Hr, installAgent as Ht, disposeSessions as I, interruptedSinceReport as In, PREF_MAX as Ir, removeServer as It, moveSession as J, onTurnEnd as Jn, setPref as Jr, runStreaming as Jt, listSessions as K, onFinished as Kn, preferredAgent as Kr, refreshGithub as Kt, ensureTmuxServer as L, lastTypedAt as Ln, WORKSPACE_PREFS as Lr, serverById as Lt, closedTeam as M, swr as Mi, agentPhase as Mn, isValidHost as Mr, forgetProbes as Mt, createSession as N, withLock as Ni, clearAgentPhase as Nn, normalizeHost as Nr, installKey as Nt, beginCreation as O, TMUX_SOCKET as Oi, cleanSummary as On, addHost as Or, stopServers as Ot, creationOf as P, hookPhase as Pn, removeHost as Pr, installServer as Pt, onSessionDispose as Q, setExpecting as Qn, ghKnownHosts as Qr, readBlobAt as Qt, forgetPanes as R, noteActivity$1 as Rn, agentChoices as Rr, serverList as Rt, withProgressOp as S, db as Si, reportsWorking as Sn, headOid as Sr, lspQuery as St, ensureAllPushHooks as T, ownsBranchOf as Ti, credentialStamp as Tn, repoCatalog as Tr, lspWarm as Tt, launchDir as U, noteTyped as Un, enabledAgents as Ur, installMise as Ut, killSession as V, notePermissionMode as Vn, deleteSetting as Vr, authGithub as Vt, listPanes as W, noteUserAnswered as Wn, getSetting as Wr, installTool as Wt, noteConversation as X, sessionWatched as Xn, discoverAgents as Xr, fileChanges as Xt, newSessionArgs as Y, onTurnFailed as Yn, setSetting as Yr, updateTool as Yt, notifySessionsChanged as Z, setAgentPhase as Zn, doctor as Zr, patchIn as Zt, retryMaterialize as _, publish as _i, noteActivity as _n, deleteSubscription as _r, killWorkspaceProc as _t, ensureUntrackedCache as a, TOOLS as ai, startSnapSweep as an, turnSince as ar, reopenSession as at, sweepTrash as b, subscriberCount as bi, quotesPastes as bn, sendPush as br, killServers as bt, insertPendingWorkspace as c, catalogPin as ci, markBranch as cn, agentFromCommand as cr, restartPlan as ct, progress as d, applyPrefChange as di, hotBatchMinMs as dn, ACCENT_RE as dr, sendToSession as dt, miseVersions as ei, reviewWaiting as en, setSessionViewers as er, paneJobs as et, progressSince as f, FRAME_ANCESTORS as fi, notePushActivity as fn, getInstance as fr, sessionInfo as ft, resumePendingWorkspaces as g, readBody as gi, workspacePrs as gn, setInstance as gr, tmuxWasStarted as gt, removeRepo as h, httpError as hi, withoutDismissed as hn, normalizeAccent as hr, tmuxName as ht, deleteWorkspace as i, PROJECT_TOOLS as ii, setPoints as in, turnSettling as ir, renameSession as it, closedSession as j, config as ji, activityOf as jn, forgetToken as jr, forgetCustomServer as jt, cleanEnv as k, git as ki, inside as kn, configuredHosts as kr, addCustomServer as kt, listWorkspaces as l, parseAgentId as li, sectionFor as ln, agentLabel as lr, restartSession as lt, queueMaterialize as m, checked as mi, refreshPrsBatch as mn, manifest as mr, setSwitch as mt, barePath as n, bornOut as ni, workspaceDiff as nn, summaryOf as nr, pasteToSession as nt, gcBares as o, agentById as oi, diffStamp as on, agentBadge as or, reopenable as ot, pruneLaneBranch as p, FRAME_HEADERS as pi, prsForHeads as pn, iconSvg as pr, sessionStates as pt, markTmuxStarted as q, onPhaseChange as qn, setDisabledAgents as qr, removeTool as qt, createWorkspace as r, firewallProbe as ri, workspaceSections as rn, turnPhase as rr, pendingSwitches as rt, getWorkspace as s, agentLabel$1 as si, commentFolder as sn, agentFamily as sr, restartOf as st, addRepo as t, which as ti, withinBudget as tn, settleQuietWorking as tr, panePids as tt, otherWorkspaceBranches as u, toolById as ui, dismissPr as un, agentMeta as ur, retireSession as ut, revParse as v, publishJson as vi, AGENTS as vn, pushPublicKey as vr, portsByWorkspace as vt, startTmpSweep as w, workspacePath as wi, blankRow as wn, repoBranches as wr, lspUses as wt, syncAgentsMd as x, all as xi, readHookPayload as xn, validSubscription as xr, lspDiagnostics as xt, setWorkspaceStatus as y, subscribe as yi, interruptKeys as yn, saveSubscription as yr, workspaceProcs as yt, getSession as z, noteBackground as zn, allPrefs as zr, sharing as zt };
+export { ownWorkspaceOnly as $, setAgentPhase as $n, doctor as $r, readBlobAt as $t, clearTmuxStarted as A, TMUX_SOCKET as Ai, cleanSummary as An, addHost as Ar, allServers as At, interruptSession as B, noteActivity$1 as Bn, agentChoices as Br, whileInstalling as Bt, workspaceBranches as C, all as Ci, readHookPayload as Cn, validSubscription as Cr, lspQueryOf as Ct, agentCaller as D, ownsBranchOf as Di, credentialStamp as Dn, repoCatalog as Dr, stopAllServers as Dt, hookToken as E, workspacePath as Ei, blankRow as En, repoBranches as Er, runningServers as Et, descendantsOf as F, withLock as Fi, clearAgentPhase as Fn, normalizeHost as Fr, lspEnabled as Ft, listPanesWithin as G, noteTyped as Gn, enabledAgents as Gr, logoutGithub as Gt, killWorkspaceSessions as H, noteInterrupt as Hn, changePref as Hr, installAgent as Ht, disposeSessions as I, hookPhase as In, removeHost as Ir, removeServer as It, moveSession as J, onFinished as Jn, preferredAgent as Jr, runStreaming as Jt, listSessions as K, noteUserAnswered as Kn, getSetting as Kr, refreshGithub as Kt, ensureTmuxServer as L, hookReportedAt as Ln, unreachableRepos as Lr, serverById as Lt, closedTeam as M, tmux as Mi, realInside as Mn, ensureGitCredentials as Mr, forgetProbes as Mt, createSession as N, config as Ni, activityOf as Nn, forgetToken as Nr, installKey as Nt, beginCreation as O, ensureAllCacheConfig as Oi, readCache as On, repoDefaultBranch as Or, stopServers as Ot, creationOf as P, swr as Pi, agentPhase as Pn, isValidHost as Pr, installServer as Pt, onSessionDispose as Q, sessionWatched as Qn, discoverAgents as Qr, patchIn as Qt, forgetPanes as R, interruptedSinceReport as Rn, PREF_MAX as Rr, serverList as Rt, withProgressOp as S, subscriberCount as Si, quotesPastes as Sn, sendPush as Sr, lspQuery as St, ensureAllPushHooks as T, get as Ti, steerKeys as Tn, pendingSsoOrgs as Tr, lspWarm as Tt, launchDir as U, notePermissionMode as Un, deleteSetting as Ur, installMise as Ut, killSession as V, noteBackground as Vn, allPrefs as Vr, authGithub as Vt, listPanes as W, noteTurnFailed as Wn, disabledAgents as Wr, installTool as Wt, noteConversation as X, onTurnEnd as Xn, setPref as Xr, deferredPatch as Xt, newSessionArgs as Y, onPhaseChange as Yn, setDisabledAgents as Yr, updateTool as Yt, notifySessionsChanged as Z, onTurnFailed as Zn, setSetting as Zr, fileChanges as Zt, retryMaterialize as _, httpError as _i, withoutDismissed as _n, normalizeAccent as _r, killWorkspaceProc as _t, ensureUntrackedCache as a, firewallProbe as ai, workspaceSections as an, turnPhase as ar, reopenSession as at, sweepTrash as b, publishJson as bi, AGENTS as bn, pushPublicKey as br, killServers as bt, insertPendingWorkspace as c, agentById as ci, diffStamp as cn, agentBadge as cr, restartPlan as ct, progress as d, parseAgentId as di, sectionFor as dn, agentLabel as dr, sendToSession as dt, ghKnownHosts as ei, readFileAt as en, setExpecting as er, paneJobs as et, progressSince as f, toolById as fi, dismissPr as fn, agentMeta as fr, sessionInfo as ft, resumePendingWorkspaces as g, checked as gi, refreshPrsBatch as gn, manifest as gr, tmuxWasStarted as gt, removeRepo as h, FRAME_HEADERS as hi, prsForHeads as hn, iconSvg as hr, tmuxName as ht, deleteWorkspace as i, bornOut as ii, workspaceDiff as in, summaryOf as ir, renameSession as it, closedSession as j, git as ji, inside as jn, configuredHosts as jr, forgetCustomServer as jt, cleanEnv as k, SCRATCH_TMUX as ki, writeCache as kn, DEFAULT_HOST as kr, addCustomServer as kt, listWorkspaces as l, agentLabel$1 as li, commentFolder as ln, agentFamily as lr, restartSession as lt, queueMaterialize as m, FRAME_ANCESTORS as mi, notePushActivity as mn, getInstance as mr, setSwitch as mt, barePath as n, miseVersions as ni, sectionScope as nn, setSessionViewers as nr, pasteToSession as nt, gcBares as o, PROJECT_TOOLS as oi, setPoints as on, turnSettling as or, reopenable as ot, pruneLaneBranch as p, applyPrefChange as pi, hotBatchMinMs as pn, ACCENT_RE as pr, sessionStates as pt, markTmuxStarted as q, notifyEventOn as qn, isKnownAgent as qr, removeTool as qt, createWorkspace as r, which as ri, withinBudget as rn, settleQuietWorking as rr, pendingSwitches as rt, getWorkspace as s, TOOLS as si, startSnapSweep as sn, turnSince as sr, restartOf as st, addRepo as t, miseInstalls as ti, reviewWaiting as tn, setScrapedPhase as tr, panePids as tt, otherWorkspaceBranches as u, catalogPin as ui, markBranch as un, agentFromCommand as ur, retireSession as ut, revParse as v, readBody as vi, workspacePrs as vn, setInstance as vr, portsByWorkspace as vt, startTmpSweep as w, db as wi, reportsWorking as wn, headOid as wr, lspUses as wt, syncAgentsMd as x, subscribe as xi, interruptKeys as xn, saveSubscription as xr, lspDiagnostics as xt, setWorkspaceStatus as y, publish as yi, noteActivity as yn, deleteSubscription as yr, workspaceProcs as yt, getSession as z, lastTypedAt as zn, WORKSPACE_PREFS as zr, sharing as zt };

package/dist/{_B3z3x0nb.js → _D7kw4Cra.js}

@@ -1,4 +1,4 @@
-import { B as interruptSession, Ci as get, Cn as steerKeys, D as agentCaller, Fn as hookReportedAt, G as listPanesWithin, Gr as isKnownAgent, Jn as onTurnEnd, Kn as onFinished, Ln as lastTypedAt, M as closedTeam, Mn as agentPhase, N as createSession, On as cleanSummary, Q as onSessionDispose, Qn as setExpecting, Rr as agentChoices, Si as db, V as killSession, Wr as getSetting, Xn as sessionWatched, Yn as onTurnFailed, Z as notifySessionsChanged, ar as turnSince, at as reopenSession, bn as quotesPastes, ct as restartPlan, dt as sendToSession, et as paneJobs, hi as httpError, ir as turnSettling, it as renameSession, j as closedSession, jn as activityOf, lr as agentLabel, lt as restartSession, mt as setSwitch, nr as summaryOf, ot as reopenable, qn as onPhaseChange, rr as turnPhase, rt as pendingSwitches, sr as agentFamily, ut as retireSession, xi as all, yn as interruptKeys, z as getSession } from "./_DHaRHB4s.js";
+import { An as cleanSummary, B as interruptSession, Br as agentChoices, Ci as all, D as agentCaller, G as listPanesWithin, Jn as onFinished, Kr as getSetting, Ln as hookReportedAt, M as closedTeam, N as createSession, Nn as activityOf, Pn as agentPhase, Q as onSessionDispose, Qn as sessionWatched, Sn as quotesPastes, Ti as get, Tn as steerKeys, V as killSession, Xn as onTurnEnd, Yn as onPhaseChange, Z as notifySessionsChanged, Zn as onTurnFailed, _i as httpError, ar as turnPhase, at as reopenSession, ct as restartPlan, dr as agentLabel, dt as sendToSession, er as setExpecting, et as paneJobs, ir as summaryOf, it as renameSession, j as closedSession, lr as agentFamily, lt as restartSession, mt as setSwitch, or as turnSettling, ot as reopenable, qr as isKnownAgent, rt as pendingSwitches, sr as turnSince, ut as retireSession, wi as db, xn as interruptKeys, z as getSession, zn as lastTypedAt } from "./_Ckb53sPe.js";
 //#region src/server/messages.ts
 var team = {
 	memberGroup: () => null,