@dylanpiercey/work 0.2.53 → 0.2.55

package/dist/{_CWO9RtPZ.js → _CZ4mgOdb.js}

@@ -1,4 +1,4 @@
-import { $ as reopenSession, A as closedSession, An as onFinished, Bn as turnPhase, Dr as getSetting, Fn as setExpecting, Hn as turnSince, J as notifySessionsChanged, Kn as agentLabel, L as getSession, Mn as onTurnEnd, Nn as sessionWatched, Or as isKnownAgent, Q as renameSession, Qr as httpError, R as interruptSession, Sn as lastTypedAt, U as listPanesWithin, Vn as turnSettling, Y as onSessionDispose, _n as agentPhase, ai as db, an as interruptKeys, bn as hookReportedAt, cn as steerKeys, et as reopenable, gn as activityOf, ii as all, j as createSession, jn as onPhaseChange, nt as sendToSession, oi as get, pn as cleanSummary, tt as retireSession, z as killSession, zn as summaryOf } from "./_ByxSq8zO.js";
+import { $ as renameSession, A as closedSession, Dr as agentChoices, E as agentCaller, En as lastTypedAt, Fn as onFinished, Gn as summaryOf, In as onPhaseChange, J as notifySessionsChanged, Jn as turnSince, Kn as turnPhase, L as getSession, Ln as onTurnEnd, Nr as getSetting, Pr as isKnownAgent, Qn as agentLabel, R as interruptSession, Rn as onTurnFailed, U as listPanesWithin, Vn as setExpecting, Xn as agentFamily, Y as onSessionDispose, _n as cleanSummary, bn as activityOf, cn as interruptKeys, di as db, et as reopenSession, fi as get, fn as steerKeys, ii as httpError, it as sendToSession, j as createSession, ln as quotesPastes, nt as restartSession, qn as turnSettling, rt as retireSession, tt as reopenable, ui as all, wn as hookReportedAt, xn as agentPhase, z as killSession, zn as sessionWatched } from "./_Cb_JPQ7K.js";
 //#region src/server/messages.ts
 var team = {
 	memberGroup: () => null,
@@ -39,6 +39,8 @@ var EXCERPT = 40;
 /** A pane just started for a message can be missing from a pane list
 * taken a moment before, which is not the session exiting. */
 var START_GRACE_MS = 1e4;
+/** A failure told again only past this, unless it says something new. */
+var FAIL_RETELL_MS = 6e5;
 /** Two agents asking each other in a loop meet this; a conversation does
 * not, since every message is a turn of the agent it goes to. */
 var SEND_WINDOW_MS = 6e5;
@@ -47,6 +49,12 @@ var sends = /* @__PURE__ */ new Map();
 /** Recipients a delivery is typing into right now. */
 var delivering = /* @__PURE__ */ new Set();
 var deliveredAt = /* @__PURE__ */ new Map();
+/** When each session reopened or restarted (`reopen`): its new pane can be
+* missing from a pane list taken a moment before. */
+var startedAt = /* @__PURE__ */ new Map();
+/** What each session's askers were last told of its turn failing, and
+* when (`turnFailed`): a CLI that fails the same way again says it once. */
+var failedTold = /* @__PURE__ */ new Map();
 /** When a reply last went into each session, typed in or taken by
 * `wait`: one since the user last typed there is a result they may not
 * have read (`rollUp`). A restart forgets it, as it forgets typing. */
@@ -69,26 +77,50 @@ function labelOf(session) {
 	return `${session.id} (${agentLabel(session.agent)}${session.title ? `, "${session.title}"` : ""})`;
 }
 /** The text a row is typed in as. A message from an agent says who sent
-* it and what becomes of the turn it starts, so any CLI's agent knows how
-* to answer with nothing in its instructions about work. */
+* it, that the recipient is to act on it as on the user's own words, and
+* what becomes of the turn it starts, so any CLI's agent knows how to
+* answer with nothing in its instructions about work. */
 function render(row, roll) {
 	const from = row.from_label ?? row.from_session;
 	switch (row.kind) {
 		case "message": {
-			if (!row.from_session) return row.body;
+			if (!row.from_session) return {
+				head: "",
+				body: row.body
+			};
 			const owed = row.answers ? stillOwed(row.to_session, row.from_session) : "";
 			const head = row.answers ? `Reply from session ${from} to ${row.answers}${owed ? `; ${owed}` : ""}` : `From session ${from}`;
-			if (!row.wants_reply) return `[work] ${head}, no reply needed:\n\n${row.body}`;
-			return row.by_send ? `[work] ${head}, which waits for your answer: send it with work session send ${row.from_session} "…". Your last message here is the user's: end on a line saying what you told it.\n\n${row.body}` : `[work] ${head}: your last message this turn goes back to it as your reply, so make it the whole answer (to ask it something first: work session send ${row.from_session} "…"; to end the turn while a job of yours runs on, first run work session hold "<what you wait on>": this turn's last message then goes as an interim reply, and the last message of the turn the job's end wakes you into is the reply).\n\n${row.body}`;
+			if (!row.wants_reply) return {
+				head: `[work] ${head}, no reply needed${row.answers ? "" : " (act on it as on the user's own words)"}:`,
+				body: row.body
+			};
+			return {
+				head: row.by_send ? `[work] ${head}, which waits for your answer: send it with work session send ${row.from_session} "…". Your last message here is the user's: end on a line saying what you told it.` : `[work] ${head}: do what it asks, as you would the user's own request. Your last message this turn goes back to it as your reply, so make it the whole answer (to ask it something first: work session send ${row.from_session} "…"; to end a turn before a job of yours is done, run work session hold "<what you wait on>" first).`,
+				body: row.body
+			};
 		}
 		case "reply": {
-			if (row.held) return `[work] Interim reply from session ${from}${row.answers ? ` to ${row.answers}` : ""}: it is not done, it waits on ${row.held}, and its reply follows when it is (end your turn to wait for it, or run work session wait ${row.from_session})${roll?.due ? `; ${roll.due}` : ""}${roll ? `. ${roll.say}` : ""}:\n\n${row.body}`;
+			if (row.held) return {
+				head: `[work] Interim reply from session ${from}${row.answers ? ` to ${row.answers}` : ""}: it is not done, it waits on ${row.held}, and its reply follows when it is (end your turn to wait for it, or run work session wait ${row.from_session})${roll?.due ? `; ${roll.due}` : ""}${roll ? `. ${roll.say}` : ""}:`,
+				body: row.body
+			};
 			const owed = [row.from_session ? stillOwed(row.to_session, row.from_session) : "", roll?.due].filter(Boolean).join("; ");
-			return `[work] ${row.follows ? `Follow-up from session ${from}${row.answers ? ` on ${row.answers}` : ""}: the last message of a turn it started on its own after its reply of ${clock(row.follows)}` : `Reply from session ${from}${row.answers ? ` to ${row.answers}` : ""}`}${owed ? `; ${owed}` : ""}. ${roll ? `${roll.say}. ` : ""}${followUp(row.from_session ?? "<id>", row.to_session)}:\n\n${row.body}`;
+			return {
+				head: `[work] ${row.follows ? `Follow-up from session ${from}${row.answers ? ` on ${row.answers}` : ""}: the last message of a turn it started on its own after its reply of ${clock(row.follows)}` : `Reply from session ${from}${row.answers ? ` to ${row.answers}` : ""}`}${owed ? `; ${owed}` : ""}. ${roll ? `${roll.say}. ` : ""}${followUp(row.from_session ?? "<id>", row.to_session)}:`,
+				body: row.body
+			};
 		}
-		case "closed": return roll ? `[work] ${row.body}${roll.due ? ` ${roll.due[0].toUpperCase()}${roll.due.slice(1)}.` : ""} ${roll.say}.` : `[work] ${row.body}`;
+		case "closed":
+		case "notice": return {
+			head: roll ? `[work] ${row.body}${roll.due ? ` ${roll.due[0].toUpperCase()}${roll.due.slice(1)}.` : ""} ${roll.say}.` : `[work] ${row.body}`,
+			body: ""
+		};
 	}
 }
+/** Typed rows as one text: each head over what it carries. */
+function joined(items) {
+	return items.map((t) => [t.head, t.body].filter(Boolean).join("\n\n")).join("\n\n");
+}
 /** A moment as a reply names it ("14:05"). */
 function clock(at) {
 	return new Date(at).toLocaleTimeString("en-GB", {
@@ -161,7 +193,7 @@ function followUp(id, asker) {
 	const send = `To follow up: work session send ${id} "…"`;
 	const c = team.closing(id, asker);
 	if (!c) return send;
-	if (c.closed) return c.reopens ? `${send}, which reopens it on its conversation (it has closed since)` : "It has closed since, and its conversation with it: to follow up, start a new session";
+	if (c.closed) return c.reopens ? `${send}, which reopens it on its conversation (it has closed since)` : c.restarts ? `It has closed since: to follow up, \`work session reopen ${id}\` starts it again on its conversation, then send` : "It has closed since, and its conversation with it: to follow up, start a new session";
 	return c.reopens ? `${send} (it closes ${c.when}, and a message then reopens it on its conversation; \`work session keep ${id}\` keeps it open)` : `${send} (it closes ${c.when}, and its conversation with it: \`work session keep ${id}\` keeps it for follow-ups)`;
 }
 /** What becomes of a group's members once done with, for its head. */
@@ -183,12 +215,25 @@ function groupClosing(rows) {
 * under its name. */
 function renderGroup(groupId, rows, roll) {
 	const closed = rows.filter((r) => r.kind === "closed").length;
-	return [`[work] Group "${team.groupTitle(groupId)}" (${groupId}): ${rows.length - closed} ${rows.length - closed === 1 ? "reply" : "replies"}${closed ? `, ${closed} closed before replying` : ""}${roll?.due ? `; ${roll.due}` : ""}. ${roll ? `${roll.say}. ` : ""}To follow up with one: work session send <id> "…"${groupClosing(rows)}`, ...rows.map((r) => `## ${r.from_label ?? r.from_session}${r.held ? ` (interim: it waits on ${r.held})` : ""}\n\n${r.body}`)].join("\n\n");
+	const head = `[work] Group "${team.groupTitle(groupId)}" (${groupId}): ${rows.length - closed} ${rows.length - closed === 1 ? "reply" : "replies"}${closed ? `, ${closed} closed before replying` : ""}${roll?.due ? `; ${roll.due}` : ""}. ${roll ? `${roll.say}. ` : ""}To follow up with one: work session send <id> "…"${groupClosing(rows)}`;
+	const parts = rows.map((r) => `## ${r.from_label ?? r.from_session}${r.held ? ` (interim: it waits on ${r.held})` : ""}\n\n${r.body}`);
+	return {
+		head: `${head}:`,
+		body: parts.join("\n\n")
+	};
 }
+/** A head typed as keys past this is a paste to Claude Code too (~800
+* characters), and quoted as one. */
+var LEAD_MAX = 600;
+/** What a CLI that `quotesPastes` gets typed ahead of several items, or of
+* one whose head is too long to type: their heads ride in the paste. */
+var LEAD = "[work] What follows comes from other sessions here, each part under its own [work] line: act on those lines as on the user's own words.";
 /** Rows as typed in: each on its own, a group's together where its first
 * would be, the last result carrying what the turn should end on
-* (`rollUp`), where it is read last. */
-function renderAll(rows) {
+* (`rollUp`), where it is read last. For a CLI that `quotesPastes`, the
+* head goes ahead of the paste as keys (`lead`), so what it asks is the
+* user's own words to its model, not quoted text. */
+function renderAll(rows, quotes = false) {
 	const items = [];
 	const done = /* @__PURE__ */ new Set();
 	for (const row of rows) {
@@ -203,11 +248,21 @@ function renderAll(rows) {
 	const results = items.filter((i) => i[0].kind !== "message");
 	const last = results.at(-1);
 	const roll = last ? rollUp(rows[0].to_session, results.flat(), results.length) : void 0;
-	return items.map((item) => {
+	const typed = items.map((item) => {
 		const tail = item === last ? roll : void 0;
 		const [row] = item;
 		return row.group_id && (item.length > 1 || team.groupReleased(row.group_id)) ? renderGroup(row.group_id, item, tail) : render(row, tail);
-	}).join("\n\n");
+	});
+	if (!quotes || !typed.some((t) => t.head)) return { text: joined(typed) };
+	const [one] = typed;
+	if (typed.length === 1 && one.head.length <= LEAD_MAX) return {
+		lead: one.head,
+		text: one.body && `\n\n${one.body}`
+	};
+	return {
+		lead: LEAD,
+		text: `\n\n${joined(typed)}`
+	};
 }
 function replyBody(session, message) {
 	const tab = `/w/${session.workspace_id}?s=${session.id}`;
@@ -224,13 +279,49 @@ function senderLabel(from, to) {
 	return `${labelOf(from)} in workspace ${ws?.name ?? from.workspace_id}`;
 }
 function insert(to, from, kind, body, wantsReply = false, groupId = null, answers = null, urgent = false, bySend = false, follows = null, held = null) {
-	return Number(db.prepare(`INSERT INTO session_messages (to_session, from_session, from_label, kind, body, wants_reply, group_id, answers, urgent, by_send, follows, held)
+	const id = Number(db.prepare(`INSERT INTO session_messages (to_session, from_session, from_label, kind, body, wants_reply, group_id, answers, urgent, by_send, follows, held)
          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(to, from?.id ?? null, from ? senderLabel(from, to) : null, kind, body, wantsReply ? 1 : 0, groupId, answers, urgent ? 1 : 0, bySend ? 1 : 0, follows, held).lastInsertRowid);
+	logInsert(id);
+	return id;
 }
-function deleteIds(ids) {
+/** Rows leave the queue once typed in or answered, saying how in the log
+* (`outcome`). */
+function deleteIds(ids, outcome) {
 	if (!ids.length) return;
+	logDone(ids, outcome);
 	db.prepare(`DELETE FROM session_messages WHERE id IN (${ids.map(() => "?").join(",")})`).run(...ids);
 }
+/** How long message_log keeps what went between sessions. */
+var LOG_KEEP = "-7 days";
+var PRUNE_EVERY_MS = 36e5;
+var prunedAt = 0;
+/** A row just queued, as the log keeps it (`work session log`). */
+function logInsert(id) {
+	const to = get("SELECT to_session FROM session_messages WHERE id = ?", id);
+	const target = to ? getSession(to.to_session) : void 0;
+	db.prepare(`INSERT OR REPLACE INTO message_log (id, workspace_id, to_session, to_label, from_session, from_label, kind, body, wants_reply, urgent, created_at)
+     SELECT id, ?, to_session, ?, from_session, from_label, kind, body, wants_reply, urgent, created_at FROM session_messages WHERE id = ?`).run(target?.workspace_id ?? null, target ? labelOf(target) : null, id);
+	if (Date.now() - prunedAt < PRUNE_EVERY_MS) return;
+	prunedAt = Date.now();
+	db.prepare(`DELETE FROM message_log WHERE created_at < strftime('%Y-%m-%dT%H:%M:%fZ', 'now', '${LOG_KEEP}')`).run();
+}
+var inIds = (ids) => `(${ids.map(() => "?").join(",")})`;
+/** Rows typed in (`at its prompt`, `into its turn`) or taken by `wait`. */
+function logDelivered(ids, how) {
+	if (!ids.length) return;
+	db.prepare(`UPDATE message_log SET delivered_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now'), delivered = ?
+     WHERE delivered_at IS NULL AND id IN ${inIds(ids)}`).run(how, ...ids);
+}
+function logDone(ids, outcome) {
+	if (!ids.length) return;
+	db.prepare(`UPDATE message_log SET done_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now'), outcome = ?
+     WHERE done_at IS NULL AND id IN ${inIds(ids)}`).run(outcome, ...ids);
+}
+/** What went to or from `session`, or in `workspace`, the latest `limit`,
+* oldest first. */
+function messageLog(of, limit = 50) {
+	return ("session" in of ? all("SELECT * FROM message_log WHERE to_session = ? OR from_session = ? ORDER BY id DESC LIMIT ?", of.session, of.session, limit) : all("SELECT * FROM message_log WHERE workspace_id = ? ORDER BY id DESC LIMIT ?", of.workspace, limit)).reverse();
+}
 /** Who a message is still to wake, for agent-state: a session owed a
 * reply, one with something waiting to be typed in (held for its group
 * or not), and a lead whose groups have members yet to answer — queued
@@ -269,7 +360,8 @@ async function deliver(id) {
 	if (!rows.length) return {};
 	delivering.add(id);
 	try {
-		await sendToSession(id, renderAll(rows), void 0, keys);
+		const { lead, text } = renderAll(rows, quotesPastes(getSession(id)?.agent));
+		await sendToSession(id, text, void 0, keys, lead);
 	} catch (err) {
 		return { waits: err.message };
 	} finally {
@@ -279,7 +371,8 @@ async function deliver(id) {
 	deliveredAt.set(id, Date.now());
 	if (rows.some((r) => r.kind !== "message")) repliedAt.set(id, Date.now());
 	answered.delete(id);
-	deleteIds(rows.filter((r) => !r.wants_reply).map((r) => r.id));
+	logDelivered(rows.map((r) => r.id), keys ? "into its turn" : "at its prompt");
+	deleteIds(rows.filter((r) => !r.wants_reply).map((r) => r.id), "delivered");
 	const owed = rows.filter((r) => r.wants_reply).map((r) => r.id);
 	if (owed.length) db.prepare(`UPDATE session_messages SET delivered_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
        WHERE id IN (${owed.map(() => "?").join(",")})`).run(...owed);
@@ -331,39 +424,42 @@ function kick() {
 * the user's own session's send back (`by_send`), which a send from it
 * to an asker it owes is (`answerBySend`).
 * `opts.now` sends it into the turn under way where its CLI takes one
-* there, and `opts.interrupt` stops that turn first (never a wait on the
-* user: theirs is the answer it waits for).
+* there, as one from an agent that wants no reply goes, and
+* `opts.interrupt` stops that turn first (never a wait on the user:
+* theirs is the answer it waits for); with no text, it is the sender's
+* messages already queued for `to` that go so.
 * `opts.member` is a fan-out starting a member (server/team): its group's
 * own caps bound it, not the sender's. */
 async function sendMessage(to, text, opts = {}) {
 	const known = getSession(to) ?? closedSession(to);
 	if (!known) throw httpError(404, `no session ${to}`);
+	if ("how" in known && known.how === "closed") throw httpError(409, `${to} was closed, not for being done, so a message does not reopen it: \`work session reopen ${to}\` starts it again on its own conversation, then send`);
 	if (known.agent === "shell") throw httpError(409, `${to} is a shell: a message would run as a command there, so messages go to agent sessions`);
 	if (opts.from === to) throw httpError(409, "a session cannot message itself");
+	const urgent = !!(opts.now || opts.interrupt);
+	if (!text && !urgent) throw httpError(400, "a message needs its text");
 	if (text.length > MAX_BODY) throw httpError(413, `a message is at most ${MAX_BODY} characters: write the rest to a file and send its path`);
 	const sender = opts.from ? getSession(opts.from) : void 0;
 	const from = sender && sender.agent !== "shell" ? sender : null;
 	if (!!from && from.workspace_id !== known.workspace_id) {
 		if (!(await listPanesWithin(2e3))?.some((p) => p.id === to)) throw httpError(409, `${to} is not running: a message to another workspace goes only to an agent running there`);
 	}
-	if (from && !opts.member) admit(from.id);
+	const queued = text ? [] : all("SELECT * FROM session_messages WHERE to_session = ? AND from_session IS ? AND kind = 'message' AND delivered_at IS NULL ORDER BY id", to, from?.id ?? null);
+	if (!text && !queued.length) throw httpError(409, `nothing of yours is queued for ${to}: \`--now\` with no text sends what you queued sooner`);
+	if (from && !opts.member && text) admit(from.id);
 	const live = getSession(to);
 	let target = live;
-	if (!target) {
-		delivering.add(to);
-		try {
-			target = await reopenSession(to);
-		} finally {
-			delivering.delete(to);
-		}
-	}
+	if (!target) target = (await reopen(to, { by: from?.id })).session;
 	if (!from && target.parent_id) db.prepare("UPDATE sessions SET keep = 1 WHERE id = ?").run(to);
-	const wantsReply = !!from && opts.reply !== false;
+	const wantsReply = queued.length ? queued.some((r) => r.wants_reply) : !!from && opts.reply !== false;
 	const bySend = wantsReply && !target.parent_id;
-	const answered = from ? answerBySend(from, to) : [];
-	const ahead = get("SELECT COUNT(*) AS n FROM session_messages WHERE to_session = ? AND delivered_at IS NULL", to)?.n ?? 0;
-	const urgent = !!(opts.now || opts.interrupt);
-	const id = insert(to, from, "message", text, wantsReply, null, answered.length ? yours(answered) : null, urgent, bySend);
+	const answered = from && text ? answerBySend(from, to) : [];
+	const ahead = (get("SELECT COUNT(*) AS n FROM session_messages WHERE to_session = ? AND delivered_at IS NULL", to)?.n ?? 0) - queued.length;
+	let id;
+	if (queued.length) {
+		id = queued.at(-1).id;
+		for (const table of ["session_messages", "message_log"]) db.prepare(`UPDATE ${table} SET urgent = 1 WHERE id IN ${inIds(queued.map((r) => r.id))}`).run(...queued.map((r) => r.id));
+	} else id = insert(to, from, "message", text, wantsReply, null, answered.length ? yours(answered) : null, urgent || !!from && !wantsReply, bySend);
 	recompute();
 	const interrupted = !!opts.interrupt && !!live && turnPhase(to) === "working" && !delivering.has(to) && await interruptSession(to);
 	const sent = await deliver(to);
@@ -397,16 +493,71 @@ async function sendMessage(to, text, opts = {}) {
 		/** Its messages this answers (`answerBySend`). */
 		answered: answered.length ? yours(answered, "its") : null,
 		/** It had closed, and is back on its conversation. */
-		reopened: !live
+		reopened: !live,
+		/** With no text: how many of the sender's queued messages went now. */
+		promoted: queued.length
 	};
 }
+/** Start `id` again on its own conversation (`work session reopen`, a
+* message to one closed for being done): one closed, its row back
+* (`reopenSession`), under `by` when the session that started it is gone;
+* one running, its CLI restarted (`restartSession`). With `agent`, as
+* another instance of its CLI: one whose account hit its limit goes on as
+* another's. What is queued for it and what it owes stay, for the turn a
+* 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`);
+	delivering.add(id);
+	try {
+		const live = getSession(id);
+		if (live) {
+			dropHold(id);
+			steered.delete(id);
+		}
+		const session = live ? await restartSession(id, opts.agent) : await reopenSession(id, {
+			agent: opts.agent,
+			adopt: agentCaller(opts.by)?.id
+		});
+		failedTold.delete(id);
+		startedAt.set(id, Date.now());
+		return {
+			session,
+			restarted: !!live
+		};
+	} finally {
+		delivering.delete(id);
+		kick();
+	}
+}
+/** `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
+* do; what it owes stays owed, for the turn that carries on to answer. */
+function turnFailed(id, why) {
+	const session = getSession(id);
+	if (!session) return;
+	const last = failedTold.get(id);
+	if (last?.why === why && Date.now() - last.at < FAIL_RETELL_MS) return;
+	const askers = 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", id).map((r) => getSession(r.id)).filter((s) => !!s && s.id !== id && s.agent !== "shell");
+	if (!askers.length) return;
+	failedTold.set(id, {
+		why,
+		at: Date.now()
+	});
+	const others = agentChoices().filter((a) => a.enabled && a.id !== session.agent && a.family === agentFamily(session.agent)).map((a) => a.id);
+	const move = reopenable(session) && others.length ? ` If its account is out, \`work session reopen ${id} --agent ${others[0]}\` starts it again on its conversation as ${others.join(" or ")}, then a message carries it on.` : "";
+	for (const asker of askers) insert(asker.id, session, "notice", `Session ${labelOf(session)} stopped: its turn failed (${why}). It still owes your reply, which comes once its turn goes on: a message to it, or the user typing into it, carries it on.${move}`);
+	recompute();
+	kick();
+}
 /** `from`'s send to `to` is its answer to what `to` asked it by send:
 * those messages are answered (`answerNow`'s bookkeeping), and returned
 * for the send to name. */
 function answerBySend(from, to) {
 	const owed = all("SELECT * FROM session_messages WHERE to_session = ? AND from_session = ? AND kind = 'message' AND wants_reply = 1 AND by_send = 1 AND delivered_at IS NOT NULL ORDER BY id", from.id, to);
 	if (!owed.length) return owed;
-	deleteIds(owed.map((r) => r.id));
+	deleteIds(owed.map((r) => r.id), "answered by a send");
 	noteAnswered(from.id);
 	return owed;
 }
@@ -420,7 +571,8 @@ function answerBySend(from, to) {
 function takeReplies(me, from, any = false) {
 	const wanted = (r) => !from?.length || r.from_session !== null && from.includes(r.from_session) || r.group_id !== null && from.includes(r.group_id);
 	const rows = delivering.has(me) ? [] : all("SELECT * FROM session_messages WHERE to_session = ? AND (kind != 'message' OR answers IS NOT NULL) AND delivered_at IS NULL ORDER BY id", me).filter(wanted).filter((r) => any || !r.group_id || team.groupReleased(r.group_id));
-	deleteIds(rows.filter((r) => !r.wants_reply).map((r) => r.id));
+	logDelivered(rows.map((r) => r.id), "taken by wait");
+	deleteIds(rows.filter((r) => !r.wants_reply).map((r) => r.id), "delivered");
 	const asks = rows.filter((r) => r.wants_reply).map((r) => r.id);
 	if (asks.length) db.prepare(`UPDATE session_messages SET delivered_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
        WHERE id IN (${asks.map(() => "?").join(",")})`).run(...asks);
@@ -539,7 +691,7 @@ function answerNow(id, message) {
 	}
 	if (held) db.prepare(`UPDATE session_messages SET held = NULL WHERE id IN (${owed.map(() => "?").join(",")})`).run(...owed.map((r) => r.id));
 	else {
-		deleteIds(owed.map((r) => r.id));
+		deleteIds(owed.map((r) => r.id), "answered");
 		if (askers.size) {
 			answered.set(id, {
 				askers,
@@ -629,6 +781,7 @@ function settle(id, why) {
 	steered.delete(id);
 	answered.delete(id);
 	repliedAt.delete(id);
+	failedTold.delete(id);
 	const session = getSession(id);
 	const label = session ? labelOf(session) : id;
 	const group = team.memberGroup(id);
@@ -637,6 +790,9 @@ function settle(id, why) {
 		const to = getSession(asker);
 		if (to && to.id !== id && to.agent !== "shell") insert(to.id, session ?? null, "closed", `Session ${label} ${why}`, false, group);
 	}
+	const gone = all("SELECT id, wants_reply FROM session_messages WHERE to_session = ?", id);
+	logDone(gone.filter((r) => r.wants_reply).map((r) => r.id), why.replace(/\.$/, ""));
+	logDone(gone.filter((r) => !r.wants_reply).map((r) => r.id), "dropped: its session went");
 	db.prepare("DELETE FROM session_messages WHERE to_session = ?").run(id);
 	if (group) team.memberGone(id);
 	recompute();
@@ -645,7 +801,8 @@ function settle(id, why) {
 /** The scraper found no pane for the session. */
 function sessionGone(id) {
 	if (!mailboxes.has(id) || delivering.has(id)) return;
-	if (Date.now() - (deliveredAt.get(id) ?? 0) < START_GRACE_MS) return;
+	const started = Math.max(deliveredAt.get(id) ?? 0, startedAt.get(id) ?? 0);
+	if (Date.now() - started < START_GRACE_MS) return;
 	settle(id, "exited before it replied.");
 }
 var started$1 = false;
@@ -653,10 +810,11 @@ function startMessages() {
 	if (started$1) return;
 	started$1 = true;
 	onTurnEnd(answer);
+	onTurnFailed(turnFailed);
 	onPhaseChange(kick);
 	onSessionDispose((id) => {
 		settle(id, "was closed before it replied.");
-		db.prepare("DELETE FROM session_messages WHERE from_session = ? AND delivered_at IS NOT NULL AND kind = 'message'").run(id);
+		deleteIds(all("SELECT id FROM session_messages WHERE from_session = ? AND delivered_at IS NOT NULL AND kind = 'message'", id).map((r) => r.id), "dropped: its sender closed");
 		db.prepare("UPDATE session_messages SET wants_reply = 0 WHERE from_session = ?").run(id);
 		recompute();
 	});
@@ -1043,7 +1201,7 @@ function keepSession(id) {
 	if (!getSession(id)) {
 		const closed = closedSession(id);
 		if (!closed) throw httpError(404, `no session ${id}`);
-		throw httpError(409, reopenable(closed) ? `${id} has closed: a message reopens it on its conversation (\`work session send ${id} "…"\`), and it can be kept then` : `${id} has closed, and its conversation with it: start a new session with --keep`);
+		throw httpError(409, !reopenable(closed) ? `${id} has closed, and its conversation with it: start a new session with --keep` : closed.how === "done" ? `${id} has closed: a message reopens it on its conversation (\`work session send ${id} "…"\`), and it can be kept then` : `${id} has closed: \`work session reopen ${id}\` starts it again on its conversation, and it can be kept then`);
 	}
 	db.prepare("UPDATE sessions SET keep = 1 WHERE id = ?").run(id);
 }
@@ -1056,7 +1214,8 @@ function closing(id, asker) {
 		const closed = closedSession(id);
 		return closed && {
 			closed: true,
-			reopens: reopenable(closed)
+			reopens: closed.how === "done" && reopenable(closed),
+			restarts: reopenable(closed)
 		};
 	}
 	if (!s.parent_id || s.keep) return void 0;
@@ -1103,4 +1262,4 @@ function startTeam() {
 	kickPool();
 }
 //#endregion
-export { startMessages as _, keepSession as a, retryMember as c, teamOf as d, teamsOf as f, sessionGone as g, sendMessage as h, createGroup as i, skipMember as l, messageStates as m, closeDone as n, kickPool as o, holdReply as p, closeFinished as r, memberWorkspace as s, clearGroup as t, startTeam as u, takeReplies as v };
+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 };