@dylanpiercey/work 0.2.70 → 0.2.72

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

@@ -839,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;
@@ -9667,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("./_wbrwjNyW.js").then((m) => m.notifySessionsChanged(workspaceId));
+		import("./_BA1HQgf_.js").then((m) => m.notifySessionsChanged(workspaceId));
 		return;
 	}
 	publish("sessions.changed");
@@ -11903,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;
@@ -11930,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}$/;
@@ -12060,6 +12075,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
@@ -12241,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;
@@ -12267,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
@@ -13269,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;
@@ -13289,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);
@@ -13305,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;
@@ -13332,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);
@@ -13454,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);
@@ -13483,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;
@@ -14701,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;
@@ -17793,13 +18006,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";
@@ -17807,6 +18032,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 = ?
@@ -17819,12 +18066,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
@@ -17874,11 +18123,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`}`);
@@ -17886,26 +18144,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. */
@@ -17925,6 +18218,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,
@@ -18069,7 +18364,7 @@ function notifySessionsChanged(workspaceId) {
 async function emitSessionsChanged(workspaceId) {
 	try {
 		const states = await sessionStates();
-		const { teamsOf } = await import("./_B25P__C4.js");
+		const { teamsOf } = await import("./_CfUEaP2Y.js");
 		publish("sessions.changed", {
 			workspaceId,
 			sessions: listSessions(workspaceId).map((s) => ({
@@ -20074,7 +20369,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
@@ -20098,4 +20396,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, git as Ci, inside as Cn, configuredHosts as Cr, stopServers as Ct, agentCaller as D, withLock as Di, clearAgentPhase as Dn, normalizeHost as Dr, forgetProbes as Dt, hookToken as E, swr 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, TMUX_SOCKET as Si, cleanSummary as Sn, addHost as Sr, stopAllServers as St, ensureAllPushHooks as T, config 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, tmux as wi, realInside as wn, ensureGitCredentials as wr, addCustomServer as wt, syncAgentsMd as x, SCRATCH_TMUX 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 $, 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 };