@dylanpiercey/work 0.2.69 → 0.2.71

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

@@ -2,11 +2,11 @@ import { i as __require, o as __toESM, t as __commonJSMin } from "./_BMI-E3GI.js
 import { r as require_inherits, t as require_src$1 } from "./_xlrdOUsL.js";
 import { t as require_safe_buffer } from "./_BmSjjJ2E.js";
 import { createRequire } from "node:module";
+import { execFile, execFileSync, spawn, spawnSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { AsyncLocalStorage } from "node:async_hooks";
-import { execFile, execFileSync, spawn, spawnSync } from "node:child_process";
 import fs$1 from "node:fs/promises";
 import os from "node:os";
 import { promisify } from "node:util";
@@ -184,6 +184,14 @@ try {
 * detaches every client on its socket, which on the live one cut every
 * open terminal. */
 var TMUX_SOCKET = process.env.WORK_TMUX_SOCKET || "work";
+/** Any socket but the machine's `work` is a scratch server's (smoke, a
+* repro), and its tmux server is that server's alone: it is stopped as the
+* server stops (entry.ts) and its systemd unit ends within a day however
+* the server went (`ensureTmuxServer`), where the live one outlives every
+* restart. Left to themselves, scratch runs kept a tmux server and its unit
+* each for weeks. `WORK_TMUX_KEEP=1` keeps one, for a test of what a
+* restart keeps. */
+var SCRATCH_TMUX = TMUX_SOCKET !== "work" && process.env.WORK_TMUX_KEEP !== "1";
 var execFileAsync = promisify(execFile);
 async function run$2(cmd, args, cwd, env, opts = {}) {
 	const child = execFileAsync(cmd, args, {
@@ -831,6 +839,13 @@ var STEPS = [
         ALTER TABLE sessions ADD COLUMN typed_at INTEGER;
       `);
 		}
+	},
+	{
+		version: 16,
+		name: "switching sessions",
+		up(db) {
+			db.exec("ALTER TABLE sessions ADD COLUMN switch_to TEXT;");
+		}
 	}
 ];
 var LATEST = STEPS.at(-1).version;
@@ -9659,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("./_C29NgtBI.js").then((m) => m.notifySessionsChanged(workspaceId));
+		import("./_BawMVLA9.js").then((m) => m.notifySessionsChanged(workspaceId));
 		return;
 	}
 	publish("sessions.changed");
@@ -12052,6 +12067,46 @@ var branchPrs = swr(TTL_MS, async (key, refresh) => {
 async function workspacePrs(fullName, branch, foreign, refresh = false, since) {
 	return prsForBranchPrefix(await branchPrs(branchKey(fullName, branch), refresh).catch(() => []), branch, foreign).filter((pr) => !since || pr.state === "OPEN" || !pr.updatedAt || pr.updatedAt >= since);
 }
+/** Each branch's own PRs, however long ago they finished, by
+* `fullName#branch`: what `prsForHeads` last found, kept an hour. */
+var HEADS_TTL_MS = 36e5;
+var headsFound = /* @__PURE__ */ new Map();
+/** GitHub refuses a search query past 256 characters; the rest of the
+* query (`is:pr is:closed sort:updated-desc repo:…`) takes its share. */
+var HEAD_TERMS_MAX = 160;
+/** These branches' PRs in one workspace repo, open or finished however
+* long ago. The workspace's own search keeps only its latest finished PRs
+* (`CLOSED_FIRST`), so a topic whose squash-merged PR had aged out of it
+* read as unmerged work for good. Asked for by name, only for the branches
+* `work topic` cannot otherwise account for: as few searches as the query
+* length allows (one per branch, run side by side, took GitHub 19 s for
+* three), and each branch's answer kept an hour. None of it rides the
+* status tick. */
+async function prsForHeads(fullName, heads) {
+	const now = Date.now();
+	const stale = heads.filter((h) => {
+		const seen = headsFound.get(branchKey(fullName, h));
+		return !seen || now - seen.at > HEADS_TTL_MS;
+	});
+	if (stale.length) try {
+		const { host, name } = splitRepo(fullName);
+		const upstream = await repoParent(fullName);
+		const repos = upstream ? [name, splitRepo(upstream).name] : [name];
+		const found = new Map(stale.map((h) => [h, []]));
+		const batches = [[]];
+		for (const h of stale) {
+			const batch = batches[batches.length - 1];
+			if (batch.length && [...batch, h].join(" head:").length > HEAD_TERMS_MAX) batches.push([h]);
+			else batch.push(h);
+		}
+		for (const batch of batches) for (const n of await searchPrs(host, repos, batch)) if (ownsNode(n, fullName, upstream)) found.get(n.headRefName)?.push(n);
+		for (const [h, prs] of found) headsFound.set(branchKey(fullName, h), {
+			at: now,
+			prs
+		});
+	} catch {}
+	return heads.flatMap((h) => headsFound.get(branchKey(fullName, h))?.prs ?? []);
+}
 /** Refresh many repos' PRs with one GraphQL request (vs one `gh pr list`
 * process per repo) — called from the status watcher for active
 * workspaces so open/merge/close flips surface in ~watch-tick time
@@ -17469,6 +17524,60 @@ async function workPids(argv) {
 	for (let at = process.pid; at && at > 1 && !pids.has(at) && pids.size < 32; at = argv ? argv.get(at)?.ppid : await procPpid(at)) pids.add(at);
 	return pids;
 }
+/** How long what a closed session started has to exit on its SIGTERM. */
+var SESSION_END_GRACE_MS = 5e3;
+/** Every process a session started, wherever it went since. tmux gives a
+* session's panes `WORK_SESSION_ID` and whatever they start inherits it, a
+* job detached with nohup or setsid included: once its parent is gone no
+* process tree leads back to one, and such jobs outlived their sessions
+* by days. Read from each process's environment where /proc has it; on
+* macOS, whose `ps` would mix the environment into the command line, the
+* trees under the session's panes instead (`panes`, read before the
+* session went). Never the server or what runs it. */
+async function sessionProcs(sessionId, panes) {
+	let pids;
+	if (darwin) {
+		const table = await processArgsNow();
+		const children = /* @__PURE__ */ new Map();
+		for (const [pid, row] of table) children.set(row.ppid, [...children.get(row.ppid) ?? [], pid]);
+		const seen = /* @__PURE__ */ new Set();
+		const queue = panes.filter((p) => table.has(p));
+		while (queue.length) {
+			const pid = queue.pop();
+			if (seen.has(pid)) continue;
+			seen.add(pid);
+			queue.push(...children.get(pid) ?? []);
+		}
+		pids = [...seen];
+	} else {
+		const mark = `WORK_SESSION_ID=${sessionId}\0`;
+		const names = await fs$1.readdir("/proc").catch(() => []);
+		pids = (await Promise.all(names.filter((n) => /^\d+$/.test(n)).map(async (n) => {
+			const env = await fs$1.readFile(`/proc/${n}/environ`, "latin1").catch(() => "");
+			return env.startsWith(mark) || env.includes(`\0${mark}`) ? Number(n) : 0;
+		}))).filter(Boolean);
+	}
+	const own = await workPids();
+	return pids.filter((p) => !own.has(p));
+}
+/** Ends everything a closing session started (`sessionProcs`): SIGTERM
+* now, and SIGKILL to what is still there `SESSION_END_GRACE_MS` later.
+* On Linux the second pass looks again by the environment, so a pid
+* reused meanwhile is never hit. */
+async function endSessionProcs(sessionId, panes) {
+	const first = await sessionProcs(sessionId, panes);
+	if (!first.length) return;
+	for (const pid of first) try {
+		process.kill(pid, "SIGTERM");
+	} catch {}
+	setTimeout(() => {
+		(darwin ? Promise.resolve(first) : sessionProcs(sessionId, [])).then((left) => {
+			for (const pid of left) try {
+				process.kill(pid, "SIGKILL");
+			} catch {}
+		}).catch(() => {});
+	}, SESSION_END_GRACE_MS).unref?.();
+}
 /** SIGTERM every process running inside the workspace (dev servers etc.). */
 async function killWorkspaceProcs(wsPath) {
 	for (const proc of await workspaceProcs(wsPath)) try {
@@ -17731,13 +17840,25 @@ async function killSession(id, keepChildren = false, how = "closed") {
 	if (!session) return [];
 	const family = keepChildren ? [id] : [id, ...descendantsOf(id)];
 	db.prepare(`DELETE FROM closed_sessions WHERE closed_at < strftime('%Y-%m-%dT%H:%M:%fZ', 'now', '${REOPEN_WITHIN}')`).run();
-	for (const member of family) {
-		keepClosed(member, member === id ? how : "closed");
-		await disposeSession(member);
-	}
+	linkPastUnkept(family, new Map(family.map((m) => [m, getSession(m)?.parent_id ?? null])), new Set(family.filter((m) => keepClosed(m, m === id ? how : "closed"))));
+	for (const member of family) await disposeSession(member);
 	notifySessionsChanged(session.workspace_id);
 	return family;
 }
+/** A member kept under one that was not (a shell, a session whose
+* conversation work never learned) is linked to the nearest member above
+* it that was, so `reopenTeam` still reaches it: under a parent that never
+* comes back it would stand alone. */
+function linkPastUnkept(family, parents, kept) {
+	const inFamily = new Set(family);
+	for (const member of kept) {
+		const own = parents.get(member);
+		if (!own || !inFamily.has(own) || kept.has(own)) continue;
+		let up = parents.get(own) ?? null;
+		while (up && inFamily.has(up) && !kept.has(up)) up = parents.get(up) ?? null;
+		if (up && kept.has(up)) db.prepare("UPDATE closed_sessions SET parent_id = ? WHERE id = ?").run(up, member);
+	}
+}
 /** How long a closed session can be started again: a lead's follow-ups
 * come as the user reviews its result, the same day or so. */
 var REOPEN_WITHIN = "-7 days";
@@ -17745,6 +17866,28 @@ var REOPEN_WITHIN = "-7 days";
 function noteConversation(id, conversation) {
 	db.prepare("UPDATE sessions SET conversation = ? WHERE id = ? AND conversation IS NOT ?").run(conversation, id, conversation);
 }
+/** The sessions closed with `id` and still kept (`reopenTeam`): down its
+* parent links, each closed no earlier than it — one closed on its own
+* before its lead went is not part of that close — parents before their
+* children. */
+function closedTeam(id) {
+	const lead = closedSession(id);
+	if (!lead) return [];
+	const rows = all(`SELECT * FROM closed_sessions WHERE workspace_id = ? AND id != ? AND closed_at >= ?
+       AND closed_at >= strftime('%Y-%m-%dT%H:%M:%fZ', 'now', '${REOPEN_WITHIN}')
+     ORDER BY closed_at, created_at`, lead.workspace_id, id, lead.closed_at);
+	const team = [];
+	const reached = /* @__PURE__ */ new Set([id]);
+	for (let grew = true; grew;) {
+		grew = false;
+		for (const r of rows) if (!reached.has(r.id) && r.parent_id && reached.has(r.parent_id)) {
+			reached.add(r.id);
+			team.push(r);
+			grew = true;
+		}
+	}
+	return team;
+}
 /** A closed session that can still be started again (`reopenSession`). */
 function closedSession(id) {
 	return get(`SELECT * FROM closed_sessions WHERE id = ?
@@ -17757,12 +17900,14 @@ function reopenable(s) {
 }
 /** Keep `id` as it is in closed_sessions, about to close. One closed for
 * being done is kept whatever it is, so a message to it can say why it
-* does not reopen; any other only if it can be started again. */
+* does not reopen; any other only if it can be started again. Whether it
+* was kept. */
 function keepClosed(id, how) {
 	const s = getSession(id);
-	if (!s?.workspace_id || how === "closed" && !reopenable(s)) return;
+	if (!s?.workspace_id || how === "closed" && !reopenable(s)) return false;
 	db.prepare(`INSERT OR REPLACE INTO closed_sessions (id, workspace_id, agent, title, parent_id, launch_dir, launch_mode, summary, conversation, created_at, how)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(s.id, s.workspace_id, s.agent, s.title, s.parent_id, s.launch_dir, s.launch_mode, s.summary, s.conversation, s.created_at, how);
+	return true;
 }
 /** Close a session work is done with (server/team), keeping what starts
 * it again on its own conversation (`reopenSession`): the lead that
@@ -17812,11 +17957,20 @@ async function reopenSession(id, opts = {}) {
 	notifySessionsChanged(closed.workspace_id);
 	return session;
 }
-/** Start a running session's CLI again on its own conversation, as
-* `agent` if given (`resumeAs`): one stuck at its prompt because its
-* account hit a limit goes on as another account's. Its row, what is
-* queued for it and what it owes stay (server/messages keeps them). */
-async function restartSession(id, agent) {
+/** Restarts in flight, by session (`restartOf`): an attach that ends
+* meanwhile was ended by the restart, not by its agent, so term-ws tells
+* its page to come back rather than that the session ended, and a page
+* that connects meanwhile waits for the new pane. Kept a beat past the
+* restart, since an old attach hears its end only as tmux gets to it. */
+var restarts = /* @__PURE__ */ new Map();
+var RESTART_LINGER_MS = 3e3;
+function restartOf(id) {
+	return restarts.get(id);
+}
+/** What `restartSession` would start `id` as, or why it cannot: asked
+* before a switch is scheduled (server/messages `reopen`), so a request
+* that cannot work fails as it is made, not when it comes due. */
+function restartPlan(id, agent) {
 	const s = getSession(id);
 	if (!s) throw httpError(404, `no session ${id}`);
 	if (!reopenable(s)) throw httpError(409, `${id} cannot start again on its conversation: ${canResume(s.agent) ? "work has not learned it yet (it comes with the first prompt's hook)" : `${agentLabel(s.agent)} cannot resume one`}`);
@@ -17824,26 +17978,61 @@ async function restartSession(id, agent) {
 	const wsPath = workspacePath(s.workspace_id);
 	if (!wsPath) throw httpError(409, `${id}'s workspace is gone`);
 	if (s.launch_dir && launchDir(s, wsPath) === wsPath) throw httpError(409, `${id} ran in ${s.launch_dir}, which is gone, and its conversation with it: ${START_AGAIN}`);
-	const env = cleanEnv();
-	await tmux([
-		"kill-session",
-		"-t",
-		tmuxName(id)
-	], env).catch(() => {});
-	forgetPanes();
-	clearTmuxStarted(id);
-	clearAgentPhase(id);
-	db.prepare("UPDATE sessions SET agent = ? WHERE id = ?").run(next, id);
-	const session = getSession(id);
-	await ensureTmuxServer();
-	await launchDetached(session, wsPath, env, { resume: s.conversation });
-	if (!await paneAlive(id, env)) {
-		db.prepare("UPDATE sessions SET agent = ? WHERE id = ?").run(s.agent, id);
+	return {
+		s,
+		next,
+		wsPath
+	};
+}
+/** Start a running session's CLI again on its own conversation, as
+* `agent` if given (`resumeAs`): one stuck at its prompt because its
+* account hit a limit goes on as another account's. Its row, what is
+* queued for it and what it owes stay (server/messages keeps them), and a
+* switch it was waiting on is done. */
+async function restartSession(id, agent) {
+	const { s, next, wsPath } = restartPlan(id, agent);
+	let finish;
+	const pending = new Promise((resolve) => finish = resolve);
+	restarts.set(id, pending);
+	try {
+		const env = cleanEnv();
+		await tmux([
+			"kill-session",
+			"-t",
+			tmuxName(id)
+		], env).catch(() => {});
+		forgetPanes();
+		clearTmuxStarted(id);
+		clearAgentPhase(id);
+		db.prepare("UPDATE sessions SET agent = ?, switch_to = NULL WHERE id = ?").run(next, id);
+		const session = getSession(id);
+		await ensureTmuxServer();
+		await launchDetached(session, wsPath, env, { resume: s.conversation });
+		if (!await paneAlive(id, env)) {
+			db.prepare("UPDATE sessions SET agent = ? WHERE id = ?").run(s.agent, id);
+			notifySessionsChanged(s.workspace_id);
+			throw httpError(409, `${id}'s ${agentLabel(next)} could not resume its conversation (${s.conversation})${next === s.agent ? "" : `: ${next} may keep its conversations apart from ${s.agent}'s`}, and its pane has closed: \`work session reopen ${id}\` tries again`);
+		}
 		notifySessionsChanged(s.workspace_id);
-		throw httpError(409, `${id}'s ${agentLabel(next)} could not resume its conversation (${s.conversation})${next === s.agent ? "" : `: ${next} may keep its conversations apart from ${s.agent}'s`}, and its pane has closed: \`work session reopen ${id}\` tries again`);
+		return session;
+	} finally {
+		finish();
+		setTimeout(() => {
+			if (restarts.get(id) === pending) restarts.delete(id);
+		}, RESTART_LINGER_MS).unref?.();
 	}
+}
+/** Ask for `id` to move to `agent` once it is idle (server/messages
+* `switchWhenIdle`), or take that ask back (`agent` null). */
+function setSwitch(id, agent) {
+	const s = getSession(id);
+	if (!s) return;
+	db.prepare("UPDATE sessions SET switch_to = ? WHERE id = ?").run(agent, id);
 	notifySessionsChanged(s.workspace_id);
-	return session;
+}
+/** Sessions waiting to move to another instance once idle. */
+function pendingSwitches() {
+	return all("SELECT id, switch_to FROM sessions WHERE switch_to IS NOT NULL");
 }
 /** What a session is, open or closed (`work session list <id>`, `log`):
 * undefined for one work does not know, or no longer keeps. */
@@ -17863,6 +18052,8 @@ function sessionInfo(id) {
 		kept: !!live?.keep,
 		/** Since when it is to close once nothing is lost by it (`retire`). */
 		retiring: live?.retire_at ?? null,
+		/** The instance it moves to once it is idle (`reopen --agent`). */
+		switching: live?.switch_to ?? null,
 		/** How and when it closed; null while open. */
 		closed: closed ? {
 			how: closed.how,
@@ -17931,11 +18122,13 @@ function onSessionDispose(fn) {
 }
 async function disposeSession(id) {
 	for (const fn of disposeListeners) fn(id);
+	const panes = (await listPanes() ?? []).filter((p) => p.id === id).map((p) => p.pid);
 	await tmux([
 		"kill-session",
 		"-t",
 		tmuxName(id)
 	]).catch(() => {});
+	endSessionProcs(id, panes).catch(() => {});
 	forgetPanes();
 	clearTmuxStarted(id);
 	clearAgentPhase(id);
@@ -18005,7 +18198,7 @@ function notifySessionsChanged(workspaceId) {
 async function emitSessionsChanged(workspaceId) {
 	try {
 		const states = await sessionStates();
-		const { teamsOf } = await import("./_BkRvQO5r.js");
+		const { teamsOf } = await import("./_D3ixWlKr.js");
 		publish("sessions.changed", {
 			workspaceId,
 			sessions: listSessions(workspaceId).map((s) => ({
@@ -18299,8 +18492,9 @@ async function ensureTmuxServer() {
 		"sleep",
 		"infinity"
 	], os.homedir());
+	const backstop = SCRATCH_TMUX ? ["--property=RuntimeMaxSec=1d"] : [];
 	const files = openFileLimit();
-	await start(files ? [`--property=LimitNOFILE=${files}`] : []).catch(() => files ? start([]) : Promise.reject()).catch(() => {});
+	await start([...files ? [`--property=LimitNOFILE=${files}`] : [], ...backstop]).catch(() => files ? start(backstop) : Promise.reject()).catch(() => {});
 }
 /** This server's open-file limit, for tmux's server: it holds a socket and
 * a tty for every client attached and a pty for every pane, and a systemd
@@ -19940,7 +20134,10 @@ ${repoLines}
   \`work topic list\` shows the open ones. \`<group>.<topic>\` folds topics
   into one review chip. Keep a few open per repo unless asked for a batch; a
   finding you won't fix gets a topic of its own. Work on files another open
-  branch changes goes on that branch or waits for it to merge.
+  branch changes goes on that branch or waits for it to merge. One you
+  abandon goes with \`work topic drop <topic>\` (never \`git branch -D\` or
+  \`git worktree remove\`): it says what it discards, wants \`--yes\` for
+  work no base has, and keeps the tip 30 days.
 - **One branch, one PR:** follow-ups to a change are more commits on its
   branch, PR open or not. Stack only when the user asks, or when a change of
   several hundred lines splits into parts each worth merging alone (never a
@@ -19962,7 +20159,8 @@ ${repoLines}
   follow-up and the same link shows it.
 - **PRs:** only when the user asks; the description is a few sentences on
   what changed and why, no verification logs or file lists.${independentPr}
-- **After a merge** (its PR's, or yours into the branch it stacks on):
+- **After a merge** (its PR's, yours into the branch it stacks on, or its
+  changes landing by other commits: squashed into another PR, cherry-picked):
   \`work topic done <topic> --rebase\` removes the merged topic's worktree
   (its branch stays; the app prunes it) and rebases the other open topics,
   each onto its own base (\`origin/<base>\`${featureBase ? ", a backport's `origin/<default>`" : ""}, or the branch it
@@ -20005,7 +20203,10 @@ ${repoLines}
   Claude or Codex one reopens it on its own conversation; one closed
   otherwise (with its lead, by the user), or stuck on its account's limit,
   \`work session reopen <id> [--agent <another instance>]\` starts again
-  on it, and \`work session log [<id>]\` shows what went to and from
+  on it, a busy one once it is idle. To move yourself to another account
+  (\`reopen $WORK_SESSION_ID --agent claude2\`), it happens as this turn
+  ends, your conversation, team and queue kept: say where you are, then
+  end the turn. \`work session log [<id>]\` shows what went to and from
   one and how each message went. \`kill\` and \`skip\` end the turn under
   way and what its pane runs; to lose nothing, \`forget <id>\` stops
   waiting on a reply, \`unsend <id>\` takes back a message not yet typed
@@ -20029,4 +20230,4 @@ ${repoLines}
 `;
 }
 //#endregion
-export { paneJobs as $, turnSince as $n, TOOLS as $r, setPoints as $t, clearTmuxStarted as A, interruptedSinceReport as An, PREF_MAX as Ar, lspEnabled as At, killSession as B, onFinished as Bn, preferredAgent as Br, logoutGithub as Bt, workspaceBranches as C, tmux as Ci, inside as Cn, configuredHosts as Cr, stopServers as Ct, agentCaller as D, clearAgentPhase as Dn, normalizeHost as Dr, forgetProbes as Dt, hookToken as E, withLock as Ei, agentPhase as En, isValidHost as Er, forgetCustomServer as Et, disposeSessions as F, notePermissionMode as Fn, deleteSetting as Fr, whileInstalling as Ft, listSessions as G, setAgentPhase as Gn, doctor as Gr, fileChanges as Gt, launchDir as H, onTurnEnd as Hn, setPref as Hr, removeTool as Ht, ensureTmuxServer as I, noteTurnFailed as In, disabledAgents as Ir, authGithub as It, newSessionArgs as J, setSessionViewers as Jn, miseVersions as Jr, readFileAt as Jt, markTmuxStarted as K, setExpecting as Kn, ghKnownHosts as Kr, patchIn as Kt, forgetPanes as L, noteTyped as Ln, enabledAgents as Lr, installAgent as Lt, createSession as M, noteActivity$1 as Mn, agentChoices as Mr, serverById as Mt, creationOf as N, noteBackground as Nn, allPrefs as Nr, serverList as Nt, beginCreation as O, hookPhase as On, removeHost as Or, installKey as Ot, descendantsOf as P, noteInterrupt as Pn, changePref as Pr, sharing as Pt, ownWorkspaceOnly as Q, turnSettling as Qn, PROJECT_TOOLS as Qr, workspaceSections as Qt, getSession as R, noteUserAnswered as Rn, getSetting as Rr, installMise as Rt, withProgressOp as S, git as Si, cleanSummary as Sn, addHost as Sr, stopAllServers as St, ensureAllPushHooks as T, swr as Ti, activityOf as Tn, forgetToken as Tr, allServers as Tt, listPanes as U, onTurnFailed as Un, setSetting as Ur, runStreaming as Ut, killWorkspaceSessions as V, onPhaseChange as Vn, setDisabledAgents as Vr, refreshGithub as Vt, listPanesWithin as W, sessionWatched as Wn, discoverAgents as Wr, updateTool as Wt, notifySessionsChanged as X, summaryOf as Xn, bornOut as Xr, withinBudget as Xt, noteConversation as Y, settleQuietWorking as Yn, which as Yr, reviewWaiting as Yt, onSessionDispose as Z, turnPhase as Zn, firewallProbe as Zr, workspaceDiff as Zt, retryMaterialize as _, get as _i, steerKeys as _n, pendingSsoOrgs as _r, lspQuery as _t, ensureUntrackedCache as a, applyPrefChange as ai, dismissPr as an, ACCENT_RE as ar, restartSession as at, sweepTrash as b, ensureAllCacheConfig as bi, readCache as bn, repoDefaultBranch as br, lspWarm as bt, insertPendingWorkspace as c, checked as ci, refreshPrsBatch as cn, manifest as cr, sessionInfo as ct, progress as d, publish as di, noteActivity as dn, deleteSubscription as dr, tmuxWasStarted as dt, agentById as ei, startSnapSweep as en, agentBadge as er, panePids as et, progressSince as f, publishJson as fi, AGENTS as fn, pushPublicKey as fr, killWorkspaceProc as ft, resumePendingWorkspaces as g, db as gi, reportsWorking as gn, headOid as gr, lspDiagnostics as gt, removeRepo as h, all as hi, readHookPayload as hn, validSubscription as hr, killServers as ht, deleteWorkspace as i, toolById as ii, sectionFor as in, agentMeta as ir, reopenable as it, closedSession as j, lastTypedAt as jn, WORKSPACE_PREFS as jr, removeServer as jt, cleanEnv as k, hookReportedAt as kn, unreachableRepos as kr, installServer as kt, listWorkspaces as l, httpError as li, withoutDismissed as ln, normalizeAccent as lr, sessionStates as lt, queueMaterialize as m, subscriberCount as mi, quotesPastes as mn, sendPush as mr, workspaceProcs as mt, barePath as n, catalogPin as ni, commentFolder as nn, agentFromCommand as nr, renameSession as nt, gcBares as o, FRAME_ANCESTORS as oi, hotBatchMinMs as on, getInstance as or, retireSession as ot, pruneLaneBranch as p, subscribe as pi, interruptKeys as pn, saveSubscription as pr, portsByWorkspace as pt, moveSession as q, setScrapedPhase as qn, miseInstalls as qr, readBlobAt as qt, createWorkspace as r, parseAgentId as ri, markBranch as rn, agentLabel as rr, reopenSession as rt, getWorkspace as s, FRAME_HEADERS as si, notePushActivity as sn, iconSvg as sr, sendToSession as st, addRepo as t, agentLabel$1 as ti, diffStamp as tn, agentFamily as tr, pasteToSession as tt, otherWorkspaceBranches as u, readBody as ui, workspacePrs as un, setInstance as ur, tmuxName as ut, revParse as v, workspacePath as vi, blankRow as vn, repoBranches as vr, lspQueryOf as vt, startTmpSweep as w, config as wi, realInside as wn, ensureGitCredentials as wr, addCustomServer as wt, syncAgentsMd as x, TMUX_SOCKET as xi, writeCache as xn, DEFAULT_HOST as xr, runningServers as xt, setWorkspaceStatus as y, ownsBranchOf as yi, credentialStamp as yn, repoCatalog as yr, lspUses as yt, interruptSession as z, notifyEventOn as zn, isKnownAgent as zr, installTool as zt };
+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 };