@dylanpiercey/work 0.2.60 → 0.2.61

package/dist/{_xM2b0RL4.js → _BL9uMFqY.js}

@@ -819,6 +819,16 @@ var STEPS = [
         CREATE INDEX message_log_to ON message_log(to_session);
         CREATE INDEX message_log_from ON message_log(from_session);
         CREATE INDEX message_log_workspace ON message_log(workspace_id, created_at);
+      `);
+		}
+	},
+	{
+		version: 15,
+		name: "retiring sessions, typing kept",
+		up(db) {
+			db.exec(`
+        ALTER TABLE sessions ADD COLUMN retire_at TEXT;
+        ALTER TABLE sessions ADD COLUMN typed_at INTEGER;
       `);
 		}
 	}
@@ -9479,8 +9489,12 @@ function activityOf(sessionId) {
 }
 /** Someone typed into the session's pane from a page. */
 function noteTyped(sessionId) {
-	typedAt.set(sessionId, Date.now());
+	const now = Date.now();
+	const last = typedAt.get(sessionId) ?? 0;
+	typedAt.set(sessionId, now);
+	if (now - last >= TYPED_KEEP_MS) db.prepare("UPDATE sessions SET typed_at = ? WHERE id = ?").run(now, sessionId);
 }
+var TYPED_KEEP_MS = 1e3;
 /** When someone last typed into the session's pane (0: not this run). */
 function lastTypedAt(sessionId) {
 	return typedAt.get(sessionId) ?? 0;
@@ -9644,7 +9658,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("./_BA6kJ94f.js").then((m) => m.notifySessionsChanged(workspaceId));
+		import("./_BOUuiLtz.js").then((m) => m.notifySessionsChanged(workspaceId));
 		return;
 	}
 	publish("sessions.changed");
@@ -17378,6 +17392,61 @@ async function foregroundRun(panePid, command) {
 	if (!argv?.length) return false;
 	return !!await headlessRun(job, argv[0].split("/").pop() || argv[0], argv.slice(1), table?.get(job)?.tty);
 }
+/** Shells an agent CLI runs its commands in: Claude's Bash tool, Codex's
+* exec. A CLI's other children (stdio MCP servers, language servers) live
+* as long as it does and are none of its jobs. */
+var SHELLS = /* @__PURE__ */ new Set([
+	"bash",
+	"sh",
+	"zsh",
+	"fish",
+	"dash",
+	"ksh"
+]);
+var baseName = (arg) => (arg.split("/").pop() || arg).replace(/^-/, "");
+/** What a CLI at `panePid` still runs in shells of its own — a background
+* job, a dev server, a test run left going — each named by what its
+* shell runs (`pnpm test`), else the shell. Closing or restarting the CLI
+* ends them all with its tmux session, so a close that loses nothing
+* waits for none (server/team `closeBlockers`). */
+async function shellJobs(panePid) {
+	if (darwin) {
+		const table = await processArgs();
+		const kids = (pid) => [...table].filter(([, row]) => row.ppid === pid);
+		return kids(panePid).filter(([, row]) => SHELLS.has(baseName(row.argv[0] ?? ""))).map(([pid, row]) => jobName(kids(pid)[0]?.[1].argv ?? row.argv));
+	}
+	const jobs = [];
+	for (const pid of await childPids(panePid)) {
+		const stat = await procStat(pid);
+		if (!stat.length || stat[0] === "Z") continue;
+		const argv = await procArgs(pid);
+		if (!SHELLS.has(baseName(argv[0] ?? ""))) continue;
+		const [first] = await childPids(pid);
+		jobs.push(jobName(first ? await procArgs(first) : argv));
+	}
+	return jobs;
+}
+/** A job as a line: its command and arguments, paths by their names. */
+function jobName(argv) {
+	const line = argv.map((arg) => arg.startsWith("/") ? baseName(arg) : arg).join(" ");
+	return line.length > 60 ? `${line.slice(0, 59)}…` : line;
+}
+/** A process's children on Linux, every thread's (a Node CLI forks from
+* its worker threads too). */
+async function childPids(pid) {
+	let tasks;
+	try {
+		tasks = await fs$1.readdir(`/proc/${pid}/task`);
+	} catch {
+		return [];
+	}
+	const kids = /* @__PURE__ */ new Set();
+	for (const task of tasks) try {
+		const list = await fs$1.readFile(`/proc/${pid}/task/${task}/children`, "utf8");
+		for (const kid of list.split(" ")) if (kid.trim()) kids.add(Number(kid));
+	} catch {}
+	return [...kids];
+}
 /** Whether a process reads a terminal: its stdin on Linux; on macOS,
 * where a look at one pid's descriptors costs a spawn, whether it has a
 * controlling terminal at all (`ps`'s `??`). Unknown counts as one. */
@@ -17789,6 +17858,10 @@ function sessionInfo(id) {
 		workspace: s.workspace_id,
 		parent: s.parent_id,
 		summary: s.summary,
+		/** Never closed for being done (`work session keep`). */
+		kept: !!live?.keep,
+		/** Since when it is to close once nothing is lost by it (`retire`). */
+		retiring: live?.retire_at ?? null,
 		/** How and when it closed; null while open. */
 		closed: closed ? {
 			how: closed.how,
@@ -17805,6 +17878,37 @@ function paneAlive(id, env) {
 		tmuxName(id)
 	], env).then(() => true, () => false);
 }
+/** What the session's CLI still runs in shells of its own (procs
+* `shellJobs`): its tmux session's close or a restart ends them. */
+async function paneJobs(id) {
+	const pane = (await listPanes())?.find((p) => p.id === id);
+	return pane ? shellJobs(pane.pid) : [];
+}
+/** Put a running session under `parent` (`work session adopt`), or on its
+* own with null (`release`), as `new` would have started it: nothing
+* restarts, and what is queued for it or owed keeps how it is answered
+* (a row's `by_send`). Adopted, it is kept from closing for being done
+* unless `closeDone`, which counts only answers to come: it may have
+* answered someone long ago. Moving one from another lead takes `from`
+* naming that lead. */
+function moveSession(id, parent, opts = {}) {
+	const s = getSession(id);
+	if (!s) throw httpError(404, `no session ${id}`);
+	if (parent === null) {
+		if (s.parent_id) db.prepare("UPDATE sessions SET parent_id = NULL WHERE id = ?").run(id);
+	} else {
+		const lead = getSession(parent);
+		if (!lead) throw httpError(404, `no session ${parent}`);
+		if (lead.workspace_id !== s.workspace_id) throw httpError(409, `${parent} is in another workspace than ${id}`);
+		if (lead.agent === "shell") throw httpError(409, `${parent} is a shell: only an agent leads`);
+		if (parent === id) throw httpError(409, `${id} cannot be under itself`);
+		if (descendantsOf(id).includes(parent)) throw httpError(409, `${parent} is under ${id} already: ${id} cannot also be under it (\`work session release ${parent}\` first)`);
+		if (s.parent_id && s.parent_id !== parent && opts.from !== s.parent_id) throw httpError(409, `${id} is under ${s.parent_id}: pass --from ${s.parent_id} to move it`);
+		db.prepare(`UPDATE sessions SET parent_id = ?, keep = ?${opts.closeDone ? ", answered_at = NULL" : ""} WHERE id = ?`).run(parent, opts.closeDone ? 0 : 1, id);
+	}
+	notifySessionsChanged(s.workspace_id);
+	return getSession(id);
+}
 /** Every session `id` started, and theirs, nearest first. */
 function descendantsOf(id) {
 	return all(`WITH RECURSIVE kids(id, depth) AS (
@@ -17900,7 +18004,7 @@ function notifySessionsChanged(workspaceId) {
 async function emitSessionsChanged(workspaceId) {
 	try {
 		const states = await sessionStates();
-		const { teamsOf } = await import("./_T5K2qs5u.js");
+		const { teamsOf } = await import("./_C-c452mk.js");
 		publish("sessions.changed", {
 			workspaceId,
 			sessions: listSessions(workspaceId).map((s) => ({
@@ -19627,7 +19731,12 @@ ${repoLines}
   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
-  one and how each message went. For a quick
+  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
+  in, \`retire <id>\` closes one once it is idle, and \`adopt <id>\` /
+  \`release <id>\` move one under you or off (the user's own only when
+  they ask, with \`--yes\`). For a quick
   sweep in your own CLI, its own subagents are cheaper. All of this is
   this workspace's only; an agent in another can be messaged when the user
   asks, and only while it runs (\`work workspaces\` lists them, \`work session list <workspace>\`
@@ -19645,4 +19754,4 @@ ${repoLines}
 `;
 }
 //#endregion
-export { renameSession as $, agentFromCommand as $n, catalogPin as $r, commentFolder as $t, closedSession as A, noteBackground as An, allPrefs as Ar, serverList as At, killWorkspaceSessions as B, onTurnFailed as Bn, setSetting as Br, runStreaming as Bt, workspaceBranches as C, withLock as Ci, agentPhase as Cn, isValidHost as Cr, forgetCustomServer as Ct, beginCreation as D, interruptedSinceReport as Dn, PREF_MAX as Dr, lspEnabled as Dt, agentCaller as E, hookReportedAt as En, unreachableRepos as Er, installServer as Et, ensureTmuxServer as F, noteUserAnswered as Fn, getSetting as Fr, installMise as Ft, markTmuxStarted as G, setSessionViewers as Gn, miseVersions as Gr, readFileAt as Gt, listPanes as H, setAgentPhase as Hn, doctor as Hr, fileChanges as Ht, forgetPanes as I, notifyEventOn as In, isKnownAgent as Ir, installTool as It, notifySessionsChanged as J, turnPhase as Jn, firewallProbe as Jr, workspaceDiff as Jt, newSessionArgs as K, settleQuietWorking as Kn, which as Kr, reviewWaiting as Kt, getSession as L, onFinished as Ln, preferredAgent as Lr, logoutGithub as Lt, creationOf as M, notePermissionMode as Mn, deleteSetting as Mr, whileInstalling as Mt, descendantsOf as N, noteTurnFailed as Nn, disabledAgents as Nr, authGithub as Nt, cleanEnv as O, lastTypedAt as On, WORKSPACE_PREFS as Or, removeServer as Ot, disposeSessions as P, noteTyped as Pn, enabledAgents as Pr, installAgent as Pt, pasteToSession as Q, agentFamily as Qn, agentLabel$1 as Qr, diffStamp as Qt, interruptSession as R, onPhaseChange as Rn, setDisabledAgents as Rr, refreshGithub as Rt, withProgressOp as S, swr as Si, activityOf as Sn, forgetToken as Sr, allServers as St, hookToken as T, hookPhase as Tn, removeHost as Tr, installKey as Tt, listPanesWithin as U, setExpecting as Un, ghKnownHosts as Ur, patchIn as Ut, launchDir as V, sessionWatched as Vn, discoverAgents as Vr, updateTool as Vt, listSessions as W, setScrapedPhase as Wn, miseInstalls as Wr, readBlobAt as Wt, ownWorkspaceOnly as X, turnSince as Xn, TOOLS as Xr, setPoints as Xt, onSessionDispose as Y, turnSettling as Yn, PROJECT_TOOLS as Yr, workspaceSections as Yt, panePids as Z, agentBadge as Zn, agentById as Zr, startSnapSweep as Zt, retryMaterialize as _, ensureAllCacheConfig as _i, readCache as _n, repoDefaultBranch as _r, lspWarm as _t, ensureUntrackedCache as a, checked as ai, refreshPrsBatch as an, manifest as ar, sessionInfo as at, sweepTrash as b, tmux as bi, inside as bn, configuredHosts as br, stopServers as bt, insertPendingWorkspace as c, publish as ci, noteActivity as cn, deleteSubscription as cr, tmuxWasStarted as ct, progress as d, subscriberCount as di, quotesPastes as dn, sendPush as dr, workspaceProcs as dt, parseAgentId as ei, markBranch as en, agentLabel as er, reopenSession as et, progressSince as f, all as fi, readHookPayload as fn, validSubscription as fr, killServers as ft, resumePendingWorkspaces as g, ownsBranchOf as gi, credentialStamp as gn, repoCatalog as gr, lspUses as gt, removeRepo as h, workspacePath as hi, blankRow as hn, repoBranches as hr, lspQueryOf as ht, deleteWorkspace as i, FRAME_HEADERS as ii, notePushActivity as in, iconSvg as ir, sendToSession as it, createSession as j, noteInterrupt as jn, changePref as jr, sharing as jt, clearTmuxStarted as k, noteActivity$1 as kn, agentChoices as kr, serverById as kt, listWorkspaces as l, publishJson as li, AGENTS as ln, pushPublicKey as lr, killWorkspaceProc as lt, queueMaterialize as m, get as mi, steerKeys as mn, pendingSsoOrgs as mr, lspQuery as mt, barePath as n, applyPrefChange as ni, dismissPr as nn, ACCENT_RE as nr, restartSession as nt, gcBares as o, httpError as oi, withoutDismissed as on, normalizeAccent as or, sessionStates as ot, pruneLaneBranch as p, db as pi, reportsWorking as pn, headOid as pr, lspDiagnostics as pt, noteConversation as q, summaryOf as qn, bornOut as qr, withinBudget as qt, createWorkspace as r, FRAME_ANCESTORS as ri, hotBatchMinMs as rn, getInstance as rr, retireSession as rt, getWorkspace as s, readBody as si, workspacePrs as sn, setInstance as sr, tmuxName as st, addRepo as t, toolById as ti, sectionFor as tn, agentMeta as tr, reopenable as tt, otherWorkspaceBranches as u, subscribe as ui, interruptKeys as un, saveSubscription as ur, portsByWorkspace as ut, revParse as v, TMUX_SOCKET as vi, writeCache as vn, DEFAULT_HOST as vr, runningServers as vt, ensureAllPushHooks as w, clearAgentPhase as wn, normalizeHost as wr, forgetProbes as wt, syncAgentsMd as x, config as xi, realInside as xn, ensureGitCredentials as xr, addCustomServer as xt, setWorkspaceStatus as y, git as yi, cleanSummary as yn, addHost as yr, stopAllServers as yt, killSession as z, onTurnEnd as zn, setPref as zr, removeTool as zt };
+export { panePids as $, agentBadge as $n, agentById as $r, startSnapSweep as $t, closedSession as A, lastTypedAt as An, WORKSPACE_PREFS as Ar, removeServer as At, killWorkspaceSessions as B, onPhaseChange as Bn, setDisabledAgents as Br, refreshGithub as Bt, workspaceBranches as C, config as Ci, realInside as Cn, ensureGitCredentials as Cr, addCustomServer as Ct, beginCreation as D, hookPhase as Dn, removeHost as Dr, installKey as Dt, agentCaller as E, clearAgentPhase as En, normalizeHost as Er, forgetProbes as Et, ensureTmuxServer as F, noteTurnFailed as Fn, disabledAgents as Fr, authGithub as Ft, markTmuxStarted as G, setExpecting as Gn, ghKnownHosts as Gr, patchIn as Gt, listPanes as H, onTurnFailed as Hn, setSetting as Hr, runStreaming as Ht, forgetPanes as I, noteTyped as In, enabledAgents as Ir, installAgent as It, noteConversation as J, settleQuietWorking as Jn, which as Jr, reviewWaiting as Jt, moveSession as K, setScrapedPhase as Kn, miseInstalls as Kr, readBlobAt as Kt, getSession as L, noteUserAnswered as Ln, getSetting as Lr, installMise as Lt, creationOf as M, noteBackground as Mn, allPrefs as Mr, serverList as Mt, descendantsOf as N, noteInterrupt as Nn, changePref as Nr, sharing as Nt, cleanEnv as O, hookReportedAt as On, unreachableRepos as Or, installServer as Ot, disposeSessions as P, notePermissionMode as Pn, deleteSetting as Pr, whileInstalling as Pt, paneJobs as Q, turnSince as Qn, TOOLS as Qr, setPoints as Qt, interruptSession as R, notifyEventOn as Rn, isKnownAgent as Rr, installTool as Rt, withProgressOp as S, tmux as Si, inside as Sn, configuredHosts as Sr, stopServers as St, hookToken as T, withLock as Ti, agentPhase as Tn, isValidHost as Tr, forgetCustomServer as Tt, listPanesWithin as U, sessionWatched as Un, discoverAgents as Ur, updateTool as Ut, launchDir as V, onTurnEnd as Vn, setPref as Vr, removeTool as Vt, listSessions as W, setAgentPhase as Wn, doctor as Wr, fileChanges as Wt, onSessionDispose as X, turnPhase as Xn, firewallProbe as Xr, workspaceDiff as Xt, notifySessionsChanged as Y, summaryOf as Yn, bornOut as Yr, withinBudget as Yt, ownWorkspaceOnly as Z, turnSettling as Zn, PROJECT_TOOLS as Zr, workspaceSections as Zt, retryMaterialize as _, workspacePath as _i, blankRow as _n, repoBranches as _r, lspQueryOf as _t, ensureUntrackedCache as a, FRAME_ANCESTORS as ai, hotBatchMinMs as an, getInstance as ar, retireSession as at, sweepTrash as b, TMUX_SOCKET as bi, writeCache as bn, DEFAULT_HOST as br, runningServers as bt, insertPendingWorkspace as c, httpError as ci, withoutDismissed as cn, normalizeAccent as cr, sessionStates as ct, progress as d, publishJson as di, AGENTS as dn, pushPublicKey as dr, killWorkspaceProc as dt, agentLabel$1 as ei, diffStamp as en, agentFamily as er, pasteToSession as et, progressSince as f, subscribe as fi, interruptKeys as fn, saveSubscription as fr, portsByWorkspace as ft, resumePendingWorkspaces as g, get as gi, steerKeys as gn, pendingSsoOrgs as gr, lspQuery as gt, removeRepo as h, db as hi, reportsWorking as hn, headOid as hr, lspDiagnostics as ht, deleteWorkspace as i, applyPrefChange as ii, dismissPr as in, ACCENT_RE as ir, restartSession as it, createSession as j, noteActivity$1 as jn, agentChoices as jr, serverById as jt, clearTmuxStarted as k, interruptedSinceReport as kn, PREF_MAX as kr, lspEnabled as kt, listWorkspaces as l, readBody as li, workspacePrs as ln, setInstance as lr, tmuxName as lt, queueMaterialize as m, all as mi, readHookPayload as mn, validSubscription as mr, killServers as mt, barePath as n, parseAgentId as ni, markBranch as nn, agentLabel as nr, reopenSession as nt, gcBares as o, FRAME_HEADERS as oi, notePushActivity as on, iconSvg as or, sendToSession as ot, pruneLaneBranch as p, subscriberCount as pi, quotesPastes as pn, sendPush as pr, workspaceProcs as pt, newSessionArgs as q, setSessionViewers as qn, miseVersions as qr, readFileAt as qt, createWorkspace as r, toolById as ri, sectionFor as rn, agentMeta as rr, reopenable as rt, getWorkspace as s, checked as si, refreshPrsBatch as sn, manifest as sr, sessionInfo as st, addRepo as t, catalogPin as ti, commentFolder as tn, agentFromCommand as tr, renameSession as tt, otherWorkspaceBranches as u, publish as ui, noteActivity as un, deleteSubscription as ur, tmuxWasStarted as ut, revParse as v, ownsBranchOf as vi, credentialStamp as vn, repoCatalog as vr, lspUses as vt, ensureAllPushHooks as w, swr as wi, activityOf as wn, forgetToken as wr, allServers as wt, syncAgentsMd as x, git as xi, cleanSummary as xn, addHost as xr, stopAllServers as xt, setWorkspaceStatus as y, ensureAllCacheConfig as yi, readCache as yn, repoDefaultBranch as yr, lspWarm as yt, killSession as z, onFinished as zn, preferredAgent as zr, logoutGithub as zt };

package/dist/_BOUuiLtz.js

@@ -0,0 +1,2 @@
+import { Y as notifySessionsChanged } from "./_BL9uMFqY.js";
+export { notifySessionsChanged };

package/dist/_C-c452mk.js

@@ -0,0 +1,2 @@
+import { h as teamsOf } from "./_C_xIwbCY.js";
+export { teamsOf };

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 };