@dylanpiercey/work 0.2.60 → 0.2.62

package/dist/{_D2Un1mYs.js → _CYtDrBwm.js}

@@ -83,101 +83,101 @@ var toastTitle = {
 	warn: "_w",
 	info: "_x"
 };
-var tocDot = "_dz _ba";
+var tocDot = "_c2 _ba";
 //#endregion
 //#region src/tags/settings-agents.css.ts
-var agentRow = "_fE _dK";
-var list$3 = "_dO _c_ _dJ _dM";
-var metaChip = "_d2 _bz _by";
-var sectionCount = "_c7 _bp _bq";
-var usageNote = "_kf _by";
-var pop$2 = "_gt _bN";
-var spinner = "_gw _bD _bi";
-var toolLead = "_ge _dX";
-var name$4 = "_fO _dX";
-var desc$1 = "_fP _dY";
+var agentRow = "_eW _d7";
+var list$3 = "_ea _dd _d6 _d9";
+var metaChip = "_eo _bz _by";
+var sectionCount = "_da _bp _bq";
+var usageNote = "_kj _by";
+var pop$2 = "_hQ _bN";
+var spinner = "_hT _bD _bi";
+var toolLead = "_hv _ej";
+var name$4 = "_h0 _ej";
+var desc$1 = "_h1 _ek";
 //#endregion
 //#region src/tags/lsp-add-dialog.css.ts
-var addDlg = "_k_ _bX";
-var key$1 = "_mG _mE";
-var addTile = "_mI _mE";
-var field$2 = "_mT _bA";
-var keyField = "_mU _mT _bA";
-var labelField = "_mV _mT _bA";
-var detailsToggle = "_hR _6";
-var themeSeg = "_fW _bR";
-var checkList = "_es _c8";
+var addDlg = "_j8 _b4";
+var key$1 = "_lC _lA";
+var addTile = "_lE _lA";
+var field$2 = "_lP _bA";
+var keyField = "_lQ _lP _bA";
+var labelField = "_lR _lP _bA";
+var detailsToggle = "_gP _6";
+var themeSeg = "_fL _bR";
+var checkList = "_gc _db";
 //#endregion
 //#region src/tags/prompt-dialog.css.ts
-var promptDlg = "_b1 _bX";
-var item$1 = "_b6 _D";
-var glance = "_dG _D";
+var promptDlg = "_b8 _b4";
+var item$1 = "_b0 _D";
+var glance = "_d3 _D";
 //#endregion
 //#region src/tags/side-nav.css.ts
-var iconBtn = "_cl _D";
-var settingsDot = "_cm _bQ";
-var notifyBtn = "_cr _D";
+var iconBtn = "_ca _D";
+var settingsDot = "_cb _bQ";
+var notifyBtn = "_cg _D";
 //#endregion
 //#region src/styles/session-pop.css.ts
-var sessionPop = "_cj _bN";
-var sessionPopBtn = "_ck _bk";
-var wsBtn = "_hp _bk";
-var rowIcon = "_hr _bF _D";
-var prChip = "_nE _M _nu";
+var sessionPop = "_b9 _bN";
+var sessionPopBtn = "_b_ _bk";
+var wsBtn = "_eI _bk";
+var rowIcon = "_eK _bF _D";
+var prChip = "_k0 _M _kU";
 //#endregion
 //#region src/tags/port-chip.css.ts
-var port = "_oT _M _nu";
+var port = "_oO _M _kU";
 var depth = {
-	"1": "_m4",
-	"2": "_m5",
-	"3": "_m6"
+	"1": "_l5",
+	"2": "_l6",
+	"3": "_l7"
 };
-var open = "_nb _bk";
-var action = "_ng _bI _D";
-var toggle = "_d7 _6";
-var fold = "_d8 _dL";
+var open = "_mc _bk";
+var action = "_mh _bI _D";
+var toggle = "_et _6";
+var fold = "_eu _d8";
 var statusOf = {
-	queued: "_lY",
-	starting: "_lZ",
-	working: "_l0",
-	waiting: "_l1",
-	idle: "_l2",
-	done: "_l3",
-	closed: "_l4"
+	queued: "_nb",
+	starting: "_nc",
+	working: "_nd",
+	waiting: "_ne",
+	idle: "_nf",
+	done: "_ng",
+	closed: "_nh"
 };
-var item = "_mz _bk";
-var menu = "_lu _cj _bN";
-var menuItem = "_lw _bk";
-var findBtn$1 = "_ih _h3 _bG _D";
-var tool = "_h3 _bG _D";
-var heldRefresh = "_ia _M";
-var pop$1 = "_mh _cj _bN";
-var fileFilter = "_pb _F";
-var findInput = "_eD _F";
-var keybarIconBtn = "_eM _bI _D";
-var input = "_cN _F";
-var group = "_cQ _6";
-var hint$1 = "_mm _bp _3";
+var item = "_kw _bk";
+var menu = "_mv _b9 _bN";
+var menuItem = "_mx _bk";
+var findBtn$1 = "_iu _if _bG _D";
+var tool = "_if _bG _D";
+var heldRefresh = "_in _M";
+var pop$1 = "_lx _b9 _bN";
+var fileFilter = "_oS _F";
+var findInput = "_g8 _F";
+var keybarIconBtn = "_hg _bI _D";
+var input = "_du _F";
+var group = "_dx _6";
+var hint$1 = "_pg _bp _3";
 var sheetDir = "_oG _bP";
-var upBtn = "_jt _bG _D";
-var findBtn = "_jx _h3 _bG _D";
-var goBtn = "_jy _h3 _bG _D";
+var upBtn = "_js _bG _D";
+var findBtn = "_jw _if _bG _D";
+var goBtn = "_jx _if _bG _D";
 var note = "_oN _by";
 //#endregion
 //#region src/tags/manage-workspace.css.ts
-var procCmd = "_eN _dX";
-var factCopy = "_eU _bI _D";
-var resultRow = "_kH _bk";
-var resultBranch = "_kI _d2 _bz _by _bF _D";
-var urlAction = "_kJ _d2 _bz _by _d3";
-var curRow = "_fe _dR";
+var procCmd = "_h4 _ej";
+var factCopy = "_ia _bI _D";
+var resultRow = "_kF _bk";
+var resultBranch = "_kG _eo _bz _by _bF _D";
+var urlAction = "_kH _eo _bz _by _ep";
+var curRow = "_hH _ed";
 //#endregion
 //#region src/tags/join-dialog.css.ts
-var dlg = "_nm _bX";
-var hint = "_nn _by";
-var kbtn = "_cD _bH _D";
-var repeat = "_cG _cF";
-var dpadUser = "_cJ _cF";
-var dpadEsc = "_cK _cF";
+var dlg = "_nw _b4";
+var hint = "_nx _by";
+var kbtn = "_cN _bH _D";
+var repeat = "_cQ _cP";
+var dpadUser = "_cT _cP";
+var dpadEsc = "_cU _cP";
 //#endregion
 export { field$2 as $, item as A, usageInk as At, wsBtn as B, fileFilter as C, iconBtnRow as Ct, findBtn$1 as D, prTone as Dt, tool as E, phaseIcon as Et, depth as F, settingsDot as G, sessionPopBtn as H, open as I, promptDlg as J, glance as K, port as L, fold as M, iconSize as Mt, toggle as N, mobile as Nt, menu as O, tone as Ot, action as P, sans as Pt, addTile as Q, prChip as R, keybarIconBtn as S, iconBtnLg as St, heldRefresh as T, inputLg as Tt, iconBtn as U, sessionPop as V, notifyBtn as W, themeSeg as X, checkList as Y, detailsToggle as Z, sheetDir as _, toastTitle as _t, dlg as a, name$4 as at, input as b, chipBtn as bt, resultBranch as c, spinner as ct, factCopy as d, list$3 as dt, key$1 as et, procCmd as f, metaChip as ft, upBtn as g, toastStack as gt, goBtn as h, toastKind as ht, repeat as i, desc$1 as it, statusOf as j, color as jt, menuItem as k, usageFill as kt, resultRow as l, usageNote as lt, findBtn as m, tocDot as mt, dpadUser as n, labelField as nt, hint as o, toolLead as ot, note as p, agentRow as pt, item$1 as q, kbtn as r, addDlg as rt, curRow as s, pop$2 as st, dpadEsc as t, keyField as tt, urlAction as u, sectionCount as ut, hint$1 as v, btnLg as vt, pop$1 as w, iconBtnXs as wt, findInput as x, glyphBadgeNum as xt, group as y, btnSm as yt, rowIcon as z };

package/dist/{_B5_rwv2K.js → _C_xIwbCY.js}

@@ -1,4 +1,4 @@
-import { $ as renameSession, A as closedSession, Bn as onTurnFailed, Cn as agentPhase, E as agentCaller, En as hookReportedAt, Fr as getSetting, Ir as isKnownAgent, J as notifySessionsChanged, Jn as turnPhase, L as getSession, Ln as onFinished, On as lastTypedAt, Qn as agentFamily, R as interruptSession, Rn as onPhaseChange, Sn as activityOf, U as listPanesWithin, Un as setExpecting, Vn as sessionWatched, Xn as turnSince, Y as onSessionDispose, Yn as turnSettling, dn as quotesPastes, er as agentLabel, et as reopenSession, fi as all, it as sendToSession, j as createSession, kr as agentChoices, mi as get, mn as steerKeys, nt as restartSession, oi as httpError, pi as db, qn as summaryOf, rt as retireSession, tt as reopenable, un as interruptKeys, yn as cleanSummary, z as killSession, zn as onTurnEnd } from "./_xM2b0RL4.js";
+import { A as closedSession, An as lastTypedAt, Bn as onPhaseChange, E as agentCaller, Gn as setExpecting, Hn as onTurnFailed, L as getSession, Lr as getSetting, On as hookReportedAt, Q as paneJobs, Qn as turnSince, R as interruptSession, Rr as isKnownAgent, Tn as agentPhase, U as listPanesWithin, Un as sessionWatched, Vn as onTurnEnd, X as onSessionDispose, Xn as turnPhase, Y as notifySessionsChanged, Yn as summaryOf, Zn as turnSettling, at as retireSession, ci as httpError, er as agentFamily, fn as interruptKeys, gi as get, gn as steerKeys, hi as db, it as restartSession, j as createSession, jr as agentChoices, mi as all, nr as agentLabel, nt as reopenSession, ot as sendToSession, pn as quotesPastes, rt as reopenable, tt as renameSession, wn as activityOf, xn as cleanSummary, z as killSession, zn as onFinished } from "./_BL9uMFqY.js";
 //#region src/server/messages.ts
 var team = {
 	memberGroup: () => null,
@@ -518,6 +518,13 @@ async function sendMessage(to, text, opts = {}) {
 * message starts there to answer. Its row is back before its CLI is: a
 * send meanwhile queues behind this rather than starting the CLI afresh. */
 async function reopen(id, opts = {}) {
+	if (delivering.has(id)) throw httpError(409, `${id} is being started or typed into: try again`);
+	if (getSession(id) && !opts.now) {
+		const phase = turnPhase(id);
+		const jobs = await paneJobs(id);
+		const busy = [phase === "waiting" ? "it waits on the user" : (phase || turnSettling(id)) && "its turn is under way", jobs.length && `its pane still runs ${jobs.join("; ")}`].filter(Boolean);
+		if (busy.length) throw httpError(409, `${id} is busy: ${busy.join(", and ")}. Restarting its CLI would end that: reopen it once it is idle, or pass --now to restart it anyway`);
+	}
 	if (delivering.has(id)) throw httpError(409, `${id} is being started or typed into: try again`);
 	delivering.add(id);
 	try {
@@ -541,6 +548,41 @@ async function reopen(id, opts = {}) {
 		kick();
 	}
 }
+/** `asker` no longer wants what `to` owes it (`work session forget`): its
+* messages in `to`'s turn stop wanting a reply, so that turn's end answers
+* nobody, and its messages still queued go in wanting none. A reply `to`
+* sent already still comes; `to` is told nothing and works on. Returns how
+* many it forgot. */
+function forgetReplies(asker, to) {
+	const rows = all("SELECT * FROM session_messages WHERE to_session = ? AND from_session = ? AND wants_reply = 1", to, asker);
+	if (!rows.length) return 0;
+	deleteIds(rows.filter((r) => r.delivered_at).map((r) => r.id), "forgotten by its asker");
+	const queued = rows.filter((r) => !r.delivered_at).map((r) => r.id);
+	if (queued.length) {
+		db.prepare(`UPDATE session_messages SET wants_reply = 0, by_send = 0 WHERE id IN ${inIds(queued)}`).run(...queued);
+		db.prepare(`UPDATE message_log SET wants_reply = 0 WHERE id IN ${inIds(queued)}`).run(...queued);
+	}
+	answered.get(to)?.askers.delete(asker);
+	heldTold.get(to)?.delete(asker);
+	recompute();
+	kick();
+	return rows.length;
+}
+/** Take back what `asker` queued for `to` that is not typed in yet (`work
+* session unsend`): what went in stays. Not all a fan-out member was
+* asked, which its group would wait on for nothing: that is a skip or a
+* forget. Returns how many went. */
+function withdraw(asker, to) {
+	if (delivering.has(to)) throw httpError(409, `${to} is being typed into: try again`);
+	const rows = all("SELECT * FROM session_messages WHERE to_session = ? AND from_session = ? AND kind = 'message' AND delivered_at IS NULL", to, asker);
+	if (!rows.length) throw httpError(409, `nothing of this session's is queued for ${to} (one typed in already stays in its turn)`);
+	const ids = rows.map((r) => r.id);
+	if (team.memberGroup(to) && !get(`SELECT 1 FROM session_messages WHERE to_session = ? AND from_session = ? AND wants_reply = 1 AND id NOT IN ${inIds(ids)}`, to, asker, ...ids)) throw httpError(409, `that is all ${to} was asked as a member of its group, which would then wait on it for nothing: \`work session forget\` or \`skip\` it instead`);
+	deleteIds(ids, "withdrawn by its sender");
+	recompute();
+	kick();
+	return ids.length;
+}
 /** `id`'s turn ended failing (rate limited, signed out) while it owes
 * replies: it sits at its prompt until someone carries it on, and whoever
 * waits on it would wait on, unknowing. Each is told why and what it can
@@ -880,6 +922,17 @@ function memberBySession(sessionId) {
 function changed(workspaceId) {
 	if (workspaceId) notifySessionsChanged(workspaceId);
 }
+/** The groups of `owner` with members still to answer. */
+function openGroupsOf(owner) {
+	return all(`SELECT DISTINCT g.id, g.title FROM session_groups g JOIN group_members m ON m.group_id = g.id
+     WHERE g.owner = ? AND m.state IN ('queued', 'running')`, owner);
+}
+/** Whether someone typed into `s` after `at`, as this server saw it or as
+* kept from before it started (`typed_at`). */
+function typedSince(s, at) {
+	if (!at) return false;
+	return Math.max(lastTypedAt(s.id), s.typed_at ?? 0) > Date.parse(at);
+}
 /** Whether a group still has members to answer. */
 function open(groupId) {
 	return !!get("SELECT 1 AS x FROM group_members WHERE group_id = ? AND state IN ('queued', 'running')", groupId);
@@ -965,22 +1018,80 @@ async function skipMember(memberId) {
 	}
 	changed(g.workspace_id);
 }
+/** Stop waiting on what `target` owes `asker` without stopping it (`work
+* session forget`): a session's replies, or a member's — a queued member
+* never starts, as a skip; a running one's session carries on under its
+* lead, no longer a member its group waits on. Says what it forgot. */
+function forget(asker, target) {
+	const m = get("SELECT * FROM group_members WHERE id = ?", target) ?? (() => {
+		const row = memberBySession(target);
+		return row?.state === "running" ? row : void 0;
+	})();
+	const g = m && groupOf(m.group_id);
+	if (!m || !g) {
+		const n = forgetReplies(asker, target);
+		if (!n) throw httpError(409, `${target} owes this session nothing to forget`);
+		return { replies: n };
+	}
+	if (g.owner !== asker) throw httpError(409, `${m.title} is ${g.owner}'s member, not this one's`);
+	if (m.state !== "queued" && m.state !== "running") throw httpError(409, `${m.title} is ${m.state}: its group waits on nothing`);
+	db.prepare("UPDATE group_members SET state = 'closed', note = 'forgotten', done_at = ?, session_id = NULL WHERE id = ?").run(now(), m.id);
+	if (m.session_id) forgetReplies(asker, m.session_id);
+	released(g);
+	changed(g.workspace_id);
+	return {
+		member: m.id,
+		session: m.session_id
+	};
+}
+/** What closing `s` now would lose, as reasons to wait (`retire`, the
+* reaper, Close done), none when nothing: a turn under way, what is
+* queued for it or owed by or to it, sessions it leads, its pane's jobs
+* (a background run, a dev server) that its tmux session's close ends,
+* and — unless the user asked for this close (`watched: false`) — its
+* being on their screen. */
+async function closeBlockers(s, opts = {}) {
+	const why = [];
+	const phase = turnPhase(s.id);
+	if (phase === "waiting") why.push("it waits on the user");
+	else if (phase || turnSettling(s.id)) why.push("its turn is under way");
+	const queued = get("SELECT COUNT(*) AS n FROM session_messages WHERE to_session = ? AND delivered_at IS NULL", s.id)?.n ?? 0;
+	if (queued) why.push(`${queued} ${queued === 1 ? "message is" : "messages are"} queued for it`);
+	const owes = all("SELECT DISTINCT from_session AS id FROM session_messages WHERE to_session = ? AND wants_reply = 1 AND delivered_at IS NOT NULL AND from_session IS NOT NULL", s.id).map((r) => r.id);
+	if (owes.length) why.push(`it owes ${owes.join(", ")} a reply`);
+	const waits = [...all("SELECT DISTINCT to_session AS id FROM session_messages WHERE from_session = ? AND wants_reply = 1", s.id).map((r) => r.id), ...openGroupsOf(s.id).map((o) => `group "${o.title}"`)];
+	if (waits.length) why.push(`it waits on replies from ${waits.join(", ")}`);
+	const leads = all("SELECT id FROM sessions WHERE parent_id = ?", s.id).map((r) => r.id);
+	if (leads.length) why.push(`it leads ${leads.join(", ")}, still open`);
+	if (opts.watched !== false && sessionWatched(s.id)) why.push("it is on the user's screen");
+	const jobs = await paneJobs(s.id);
+	if (jobs.length) why.push(`its pane still runs ${jobs.join("; ")}`);
+	return why;
+}
 /** Close the sessions of a group's members that have answered: their
 * results are kept, their CLIs no longer hold memory, and a message to
-* one reopens it. */
+* one reopens it. Not one the user kept or took over, nor one closing
+* would lose something of (`closeBlockers`). */
 async function closeDone(groupId) {
 	const g = groupOf(groupId);
 	if (!g) throw httpError(404, `no group ${groupId}`);
 	const done = membersOf(groupId).filter((m) => m.state === "done" && m.session_id);
-	for (const m of done) await retireSession(m.session_id);
+	let closed = 0;
+	for (const m of done) {
+		const s = getSession(m.session_id);
+		if (!s || s.keep || typedSince(s, s.answered_at)) continue;
+		if ((await closeBlockers(s, { watched: false })).length) continue;
+		await retireSession(s.id);
+		closed++;
+	}
 	changed(g.workspace_id);
-	return done.length;
+	return closed;
 }
 /** Forget a finished group (its members' sessions closed with it). */
 async function clearGroup(groupId) {
 	const g = groupOf(groupId);
 	if (!g) throw httpError(404, `no group ${groupId}`);
-	if (open(groupId)) throw httpError(409, `"${g.title}" still has members working: skip them first`);
+	if (open(groupId)) throw httpError(409, `"${g.title}" still has members working: skip or forget them first`);
 	await closeDone(groupId);
 	db.prepare("DELETE FROM session_groups WHERE id = ?").run(groupId);
 	changed(g.workspace_id);
@@ -1089,16 +1200,13 @@ setTeamHooks({
 		return all(`SELECT DISTINCT g.owner FROM session_groups g JOIN group_members m ON m.group_id = g.id
        WHERE m.state IN ('queued', 'running')`).map((r) => r.owner);
 	},
-	openGroups(owner) {
-		return all(`SELECT DISTINCT g.id, g.title FROM session_groups g JOIN group_members m ON m.group_id = g.id
-       WHERE g.owner = ? AND m.state IN ('queued', 'running')`, owner);
-	},
+	openGroups: openGroupsOf,
 	memberAnswered(sessionId, message) {
 		const m = memberBySession(sessionId);
 		if (!m || m.state !== "running") return;
 		db.prepare("UPDATE group_members SET state = 'done', summary = ?, note = NULL, done_at = ? WHERE id = ?").run(message ? cleanSummary(message) ?? null : null, now(), m.id);
 		const g = groupOf(m.group_id);
-		if (g.close_done) setTimeout(() => void retireSession(sessionId), 0);
+		if (g.close_done) setTimeout(() => void closeAnswered(sessionId).catch((err) => console.error(`[work] team: ${err.message}`)), 0);
 		released(g);
 		changed(g.workspace_id);
 	},
@@ -1188,34 +1296,89 @@ async function teamOf(owner) {
 * coming back to it, and each is a whole CLI's memory. */
 var REAP_IDLE_MS = 6e5;
 var REAP_EVERY_MS = 6e4;
-/** Whether a session an agent started is done with: it has answered,
-* nothing is queued or owed to it, it is at its prompt with nothing it
-* waits on (its own children working keep it: it is their lead), and the
-* user neither has it on screen nor has taken it over. */
-function doneWith(s) {
-	if (!s.parent_id || s.keep || !s.answered_at) return false;
-	if (agentPhase(s.id) !== void 0 || turnSettling(s.id)) return false;
-	if (sessionWatched(s.id)) return false;
-	if (get("SELECT 1 AS x FROM session_messages WHERE to_session = ?", s.id)) return false;
-	if (lastTypedAt(s.id) > Date.parse(s.answered_at)) {
-		db.prepare("UPDATE sessions SET keep = 1 WHERE id = ?").run(s.id);
-		return false;
+/** Whether a session is done with: one an agent started that has
+* answered, and that the user has not taken over (typed into since it
+* answered, which keeps it for good); or one asked to close once nothing
+* is lost by it (`retire_at`), not typed into since, which takes the ask
+* back. Either way only once closing it loses nothing (`closeBlockers`).
+* Read afresh: a keep, adopt or release can land while another closes. */
+async function doneWith(id) {
+	const s = getSession(id);
+	if (!s) return null;
+	if (s.retire_at) {
+		if (typedSince(s, s.retire_at)) {
+			db.prepare("UPDATE sessions SET retire_at = NULL WHERE id = ?").run(id);
+			return null;
+		}
+	} else {
+		if (!s.parent_id || s.keep || !s.answered_at) return null;
+		if (typedSince(s, s.answered_at)) {
+			db.prepare("UPDATE sessions SET keep = 1 WHERE id = ?").run(id);
+			return null;
+		}
 	}
-	return true;
-}
-/** Close the sessions an agent started that are done with: `parent`'s
-* once its job is done (or asked: `work session kill --done`), else any
-* idle past `REAP_IDLE_MS`. A fan-out member's result stays in its group,
-* and a message to one reopens it (sessions.ts `retireSession`). */
+	return closeBlockers(s);
+}
+/** Close the sessions that are done with (`doneWith`): `parent`'s once
+* its job is done (or asked: `work session kill --done`), and it too if
+* it was asked to retire; else any idle past `REAP_IDLE_MS`, and any
+* asked to retire. A fan-out member's result stays in its group, and a
+* message to one reopens it (sessions.ts `retireSession`). Says how many
+* closed, and why each done with but left open was. */
 async function closeFinished(parent) {
-	const rows = parent ? all("SELECT * FROM sessions WHERE parent_id = ?", parent) : all("SELECT * FROM sessions WHERE parent_id IS NOT NULL AND answered_at IS NOT NULL AND answered_at < ?", (/* @__PURE__ */ new Date(Date.now() - REAP_IDLE_MS)).toISOString());
+	const rows = parent ? all("SELECT id FROM sessions WHERE parent_id = ? OR (id = ? AND retire_at IS NOT NULL) ORDER BY id = ?", parent, parent, parent) : all("SELECT id FROM sessions WHERE (parent_id IS NOT NULL AND answered_at IS NOT NULL AND answered_at < ?) OR retire_at IS NOT NULL", (/* @__PURE__ */ new Date(Date.now() - REAP_IDLE_MS)).toISOString());
 	let closed = 0;
-	for (const s of rows) {
-		if (!doneWith(s)) continue;
-		await retireSession(s.id);
+	const left = [];
+	for (const { id } of rows) {
+		const why = await doneWith(id);
+		if (!why) continue;
+		if (why.length) {
+			if (id !== parent) left.push({
+				id,
+				why
+			});
+			continue;
+		}
+		await retireSession(id);
 		closed++;
 	}
-	return closed;
+	return {
+		closed,
+		left
+	};
+}
+/** A `--close-done` member that answered: closed now, unless the user
+* has it or closing would lose something (`closeBlockers`), which leaves
+* it to the reaper. */
+async function closeAnswered(id) {
+	const s = getSession(id);
+	if (!s || s.keep || typedSince(s, s.answered_at)) return;
+	if ((await closeBlockers(s)).length) return;
+	await retireSession(id);
+}
+/** Close `id` once closing it loses nothing (`work session retire`): at
+* once if that is now, else at the first sweep after — its turn's end, a
+* job's, its last message answered — unless someone types into it first.
+* Says whether it closed, or what it waits on. A message reopens it. */
+async function retire(id) {
+	const s = getSession(id);
+	if (!s) throw closedSession(id) ? httpError(409, `${id} has closed already`) : httpError(404, `no session ${id}`);
+	db.prepare("UPDATE sessions SET retire_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now') WHERE id = ?").run(id);
+	const waits = await closeBlockers(getSession(id));
+	if (!waits.length) {
+		await retireSession(id);
+		const closed = closedSession(id);
+		return {
+			closed: true,
+			reopens: !!closed && reopenable(closed),
+			waits
+		};
+	}
+	notifySessionsChanged(s.workspace_id);
+	return {
+		closed: false,
+		waits
+	};
 }
 /** Never close `id` for being done, as `--keep` would have started it
 * (`work session keep`): its lead has follow-ups for it. */
@@ -1284,4 +1447,4 @@ function startTeam() {
 	kickPool();
 }
 //#endregion
-export { sendMessage as _, keepSession as a, takeReplies as b, retryMember as c, teamOf as d, teamsOf as f, reopen as g, messageStates as h, createGroup as i, skipMember as l, messageLog as m, closeDone as n, kickPool as o, holdReply as p, closeFinished as r, memberWorkspace as s, clearGroup as t, startTeam as u, sessionGone as v, startMessages as y };
+export { takeReplies as C, startMessages as S, messageLog as _, createGroup as a, sendMessage as b, kickPool as c, retryMember as d, skipMember as f, holdReply as g, teamsOf as h, closeFinished as i, memberWorkspace as l, teamOf as m, closeBlockers as n, forget as o, startTeam as p, closeDone as r, keepSession as s, clearGroup as t, retire as u, messageStates as v, withdraw as w, sessionGone as x, reopen as y };