@dylanpiercey/work 0.2.71 → 0.2.73

package/dist/{_DHaRHB4s.js → _BiUfgowG.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("./_Dl08ohid.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}$/;
@@ -12275,6 +12283,92 @@ function sectionFor(list, id) {
 	return list.find((r) => r.worktree === repo && (r.pr?.headRefName ?? r.headRef) === `${r.branch}-${topic}`)?.id ?? null;
 }
 //#endregion
+//#region src/client/fuzzy.ts
+/** Rank an "org/name" repo against a query, weighting the name over the
+* org. Higher is better; -1 means no match (including an empty query —
+* rankRepos owns the empty-query short-circuit). */
+function repoScore(query, fullName) {
+	if (!query) return -1;
+	const q = query.toLowerCase();
+	const lower = fullName.toLowerCase();
+	const slash = lower.lastIndexOf("/");
+	const name = lower.slice(slash + 1);
+	const orgBonus = lower.slice(0, Math.max(0, slash)).includes(q) ? 5 : 0;
+	if (name === q) return 1e3 + orgBonus;
+	if (name.startsWith(q)) return 800 + orgBonus;
+	if (name.includes(q)) return 600 + orgBonus;
+	if (fuzzy(q, name)) return 400 + orgBonus;
+	if (lower.includes(q)) return 300;
+	if (fuzzy(q, lower)) return 100;
+	return -1;
+}
+/** Typeahead ranking policy for repo pickers: skip archived and excluded
+* repos, order by score (ties: shorter name, then alphabetical), top 8.
+* An empty query returns no results. */
+function rankRepos(query, repos, exclude) {
+	if (!query) return [];
+	return repos.map((repo) => ({
+		repo,
+		score: repoScore(query, repo.nameWithOwner)
+	})).filter(({ repo, score }) => !repo.isArchived && score >= 0 && !exclude(repo.nameWithOwner)).sort((a, b) => b.score - a.score || a.repo.nameWithOwner.length - b.repo.nameWithOwner.length || a.repo.nameWithOwner.localeCompare(b.repo.nameWithOwner)).slice(0, 8).map(({ repo }) => repo);
+}
+/** Subsequence match: every query char appears in order in `text`. */
+function fuzzy(query, text) {
+	if (!query) return true;
+	let i = 0;
+	const lower = text.toLowerCase();
+	for (const ch of query.toLowerCase()) {
+		i = lower.indexOf(ch, i);
+		if (i === -1) return false;
+		i++;
+	}
+	return true;
+}
+//#endregion
+//#region src/client/file-filter.ts
+/** Filter language for the review file list: space-separated terms.
+* Terms with glob characters match as globs (`*` within a segment, `**`
+* across segments, `?` one char, unanchored); plain terms keep the fuzzy
+* subsequence match; a `!` prefix excludes, and a plain excluded term
+* matches as text (case-insensitive): letters scattered in order are a
+* fair way to find a file, but would rule out most of a tree (`!test`
+* would hide `terminal-settings.ts`). A file must pass every include term and
+* no exclude term. */
+function makeFileFilter(query) {
+	const includes = [];
+	const excludes = [];
+	for (const raw of query.trim().split(/\s+/).filter(Boolean)) {
+		const negated = raw.startsWith("!");
+		const term = negated ? raw.slice(1) : raw;
+		if (!term) continue;
+		(negated ? excludes : includes).push(termMatcher(term, negated ? contains : fuzzy));
+	}
+	return (path) => !excludes.some((m) => m(path)) && includes.every((m) => m(path));
+}
+function contains(term, path) {
+	return path.toLowerCase().includes(term.toLowerCase());
+}
+function termMatcher(term, plain) {
+	if (!/[*?]/.test(term)) return (path) => plain(term, path);
+	let source = "";
+	for (let i = 0; i < term.length; i++) {
+		const ch = term[i];
+		if (ch === "*") {
+			if (term[i + 1] === "*") {
+				source += ".*";
+				i++;
+			} else source += "[^/]*";
+		} else if (ch === "?") source += "[^/]";
+		else source += ch.replace(/[.+^${}()|[\]\\]/, "\\$&");
+	}
+	try {
+		const re = new RegExp(source, "i");
+		return (path) => re.test(path);
+	} catch {
+		return (path) => plain(term, path);
+	}
+}
+//#endregion
 //#region src/server/diff-stamp.ts
 /** A cheap fingerprint of what a workspace's diff is taken from: each
 * repo's HEAD and branch state, the paths `git status` lists, and each of
@@ -12288,7 +12382,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 +12409,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 +13434,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 +13489,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 +13505,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 +13561,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 +13683,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 +13713,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 +14936,127 @@ 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.
+* A file the page's file filter hides (`filter`, its `repo/path` as the
+* page matches it) comes without its patch whatever its size, and counts
+* against no share: `!fixtures` over a topic regenerating twenty
+* thousand snapshots kept 0.9 of its 31 MB. Listed still, it keeps the
+* filter's counts, and a filter changed after the load shows it at once
+* and fetches it as it comes on screen, with no reload. The page fetches
+* a left-out file by its hash (`deferredPatch`, kept here for `wsId`).
+* The same sections at the same budget and filter come back as the same
+* object, for the route's hash. */
+function withinBudget(sections, budget, wsId, filter = "") {
 	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);
+	const key = `${budget}\0${filter}`;
+	let kept = byBudget.get(key);
+	if (!kept) {
+		kept = cutToBudget(sections, budget, filter);
+		byBudget.set(key, kept);
+	}
+	if (kept.deferred.size) holdDeferred(wsId, kept.deferred);
+	return kept.out;
+}
+var budgeted = /* @__PURE__ */ new WeakMap();
+function cutToBudget(sections, budget, filter) {
+	const deferred = /* @__PURE__ */ new Map();
+	const keyOf = (s) => s.topic ?? s.id;
+	const match = filter.trim() ? makeFileFilter(filter) : null;
+	const hidden = (s, f) => !!f.patch && !!match && !match(`${s.worktree}/${f.path}`);
+	const totals = /* @__PURE__ */ new Map();
+	let total = 0;
+	let anyHidden = false;
+	for (const s of sections) for (const f of s.files) {
+		if (hidden(s, f)) {
+			anyHidden = true;
+			continue;
+		}
+		const n = f.patch?.length ?? 0;
+		totals.set(keyOf(s), (totals.get(keyOf(s)) ?? 0) + n);
+		total += n;
+	}
+	if (total <= budget && !anyHidden) 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 total > budget ? totals : /* @__PURE__ */ new Map()) {
+		if (size <= share) continue;
+		const lengths = sections.filter((s) => keyOf(s) === topic).flatMap((s) => s.files.flatMap((f) => f.patch && !hidden(s, f) ? [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)) ?? Infinity;
+			if (cut === Infinity && !s.files.some((f) => hidden(s, f))) return s;
+			return {
+				...s,
+				files: s.files.map((f) => {
+					const filtered = hidden(s, f);
+					if (!f.patch || !filtered && 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,
+						...filtered && { filtered: true }
+					};
+				})
+			};
+		}),
+		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 +18466,7 @@ function notifySessionsChanged(workspaceId) {
 async function emitSessionsChanged(workspaceId) {
 	try {
 		const states = await sessionStates();
-		const { teamsOf } = await import("./_D3ixWlKr.js");
+		const { teamsOf } = await import("./_Cxk-BqG-.js");
 		publish("sessions.changed", {
 			workspaceId,
 			sessions: listSessions(workspaceId).map((s) => ({
@@ -20230,4 +20498,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 $, onTurnEnd as $n, setPref as $r, readBlobAt as $t, clearTmuxStarted as A, ownsBranchOf as Ai, credentialStamp as An, repoCatalog as Ar, allServers as At, interruptSession as B, hookReportedAt as Bn, unreachableRepos as Br, whileInstalling as Bt, workspaceBranches as C, publishJson as Ci, AGENTS as Cn, pushPublicKey as Cr, lspQueryOf as Ct, agentCaller as D, db as Di, reportsWorking as Dn, headOid as Dr, stopAllServers as Dt, hookToken as E, all as Ei, readHookPayload as En, validSubscription as Er, runningServers as Et, descendantsOf as F, tmux as Fi, realInside as Fn, ensureGitCredentials as Fr, lspEnabled as Ft, listPanesWithin as G, noteInterrupt as Gn, changePref as Gr, logoutGithub as Gt, killWorkspaceSessions as H, lastTypedAt as Hn, WORKSPACE_PREFS as Hr, installAgent as Ht, disposeSessions as I, config as Ii, activityOf as In, forgetToken as Ir, removeServer as It, moveSession as J, noteTyped as Jn, enabledAgents as Jr, runStreaming as Jt, listSessions as K, notePermissionMode as Kn, deleteSetting as Kr, refreshGithub as Kt, ensureTmuxServer as L, swr as Li, agentPhase as Ln, isValidHost as Lr, serverById as Lt, closedTeam as M, SCRATCH_TMUX as Mi, writeCache as Mn, DEFAULT_HOST as Mr, forgetProbes as Mt, createSession as N, TMUX_SOCKET as Ni, cleanSummary as Nn, addHost as Nr, installKey as Nt, beginCreation as O, get as Oi, steerKeys as On, pendingSsoOrgs as Or, stopServers as Ot, creationOf as P, git as Pi, inside as Pn, configuredHosts as Pr, installServer as Pt, onSessionDispose as Q, onPhaseChange as Qn, setDisabledAgents as Qr, patchIn as Qt, forgetPanes as R, withLock as Ri, clearAgentPhase as Rn, normalizeHost as Rr, serverList as Rt, withProgressOp as S, publish as Si, noteActivity as Sn, deleteSubscription as Sr, lspQuery as St, ensureAllPushHooks as T, subscriberCount as Ti, quotesPastes as Tn, sendPush as Tr, lspWarm as Tt, launchDir as U, noteActivity$1 as Un, agentChoices as Ur, installMise as Ut, killSession as V, interruptedSinceReport as Vn, PREF_MAX as Vr, authGithub as Vt, listPanes as W, noteBackground as Wn, allPrefs as Wr, installTool as Wt, noteConversation as X, notifyEventOn as Xn, isKnownAgent as Xr, deferredPatch as Xt, newSessionArgs as Y, noteUserAnswered as Yn, getSetting as Yr, updateTool as Yt, notifySessionsChanged as Z, onFinished as Zn, preferredAgent as Zr, fileChanges as Zt, retryMaterialize as _, FRAME_ANCESTORS as _i, notePushActivity as _n, getInstance as _r, killWorkspaceProc as _t, ensureUntrackedCache as a, miseVersions as ai, workspaceSections as an, setSessionViewers as ar, reopenSession as at, sweepTrash as b, httpError as bi, withoutDismissed as bn, normalizeAccent as br, killServers as bt, insertPendingWorkspace as c, firewallProbe as ci, diffStamp as cn, turnPhase as cr, restartPlan as ct, progress as d, agentById as di, rankRepos as dn, agentBadge as dr, sendToSession as dt, setSetting as ei, readFileAt as en, onTurnFailed as er, paneJobs as et, progressSince as f, agentLabel$1 as fi, commentFolder as fn, agentFamily as fr, sessionInfo as ft, resumePendingWorkspaces as g, applyPrefChange as gi, hotBatchMinMs as gn, ACCENT_RE as gr, tmuxWasStarted as gt, removeRepo as h, toolById as hi, dismissPr as hn, agentMeta as hr, tmuxName as ht, deleteWorkspace as i, miseInstalls as ii, workspaceDiff as in, setScrapedPhase as ir, renameSession as it, closedSession as j, ensureAllCacheConfig as ji, readCache as jn, repoDefaultBranch as jr, forgetCustomServer as jt, cleanEnv as k, workspacePath as ki, blankRow as kn, repoBranches as kr, addCustomServer as kt, listWorkspaces as l, PROJECT_TOOLS as li, makeFileFilter as ln, turnSettling as lr, restartSession as lt, queueMaterialize as m, parseAgentId as mi, sectionFor as mn, agentLabel as mr, setSwitch as mt, barePath as n, doctor as ni, sectionScope as nn, setAgentPhase as nr, pasteToSession as nt, gcBares as o, which as oi, setPoints as on, settleQuietWorking as or, reopenable as ot, pruneLaneBranch as p, catalogPin as pi, markBranch as pn, agentFromCommand as pr, sessionStates as pt, markTmuxStarted as q, noteTurnFailed as qn, disabledAgents as qr, removeTool as qt, createWorkspace as r, ghKnownHosts as ri, withinBudget as rn, setExpecting as rr, pendingSwitches as rt, getWorkspace as s, bornOut as si, startSnapSweep as sn, summaryOf as sr, restartOf as st, addRepo as t, discoverAgents as ti, reviewWaiting as tn, sessionWatched as tr, panePids as tt, otherWorkspaceBranches as u, TOOLS as ui, fuzzy as un, turnSince as ur, retireSession as ut, revParse as v, FRAME_HEADERS as vi, prsForHeads as vn, iconSvg as vr, portsByWorkspace as vt, startTmpSweep as w, subscribe as wi, interruptKeys as wn, saveSubscription as wr, lspUses as wt, syncAgentsMd as x, readBody as xi, workspacePrs as xn, setInstance as xr, lspDiagnostics as xt, setWorkspaceStatus as y, checked as yi, refreshPrsBatch as yn, manifest as yr, workspaceProcs as yt, getSession as z, hookPhase as zn, removeHost as zr, sharing as zt };