@dylanpiercey/work 0.2.44 → 0.2.46

package/bin/cli/session.mjs

@@ -139,9 +139,13 @@ function sentText(id, r, asked) {
 
 function printReply(r) {
   const replied = r.kind === "reply" || r.answers;
-  const head = replied
-    ? `${r.label} replied${r.answers ? ` to ${r.answers}` : ""}:`
-    : `${r.label}: ${r.text}`;
+  const head = !replied
+    ? `${r.label}: ${r.text}`
+    : r.held
+      ? `${r.label} is not done (it waits on ${r.held}), and wrote${r.answers ? ` to ${r.answers}` : ""}:`
+      : r.follows
+        ? `${r.label} followed up${r.answers ? ` on ${r.answers}` : ""}, from a turn it started on its own after its reply:`
+        : `${r.label} replied${r.answers ? ` to ${r.answers}` : ""}:`;
   console.log(head);
   if (replied) console.log(`${r.text}\n`);
   if (r.asks === "turn")
@@ -214,7 +218,7 @@ export const commands = [
   {
     name: "session",
     summary:
-      "this session and the workspace's others: new, fanout, send, wait, keep, team, kill",
+      "this session and the workspace's others: new, fanout, send, wait, hold, keep, team, kill",
     help: `work session [--json]
   This session (WORK_SESSION_ID): its id, agent, name, state, and the
   workspace it is in (id, name, path) — what a link names (/w/<id>/…).
@@ -290,6 +294,13 @@ work session wait [<id>|<group>...] [--any] [--timeout <seconds>]
   typed in too. A group's come once all its members have answered, unless
   --any: then whatever is in, as soon as anything is. Exits 124 if some
   are still working after --timeout (${WAIT_S} s).
+work session hold "<what you wait on>"
+  End this turn before your work is done — a job of yours runs on, and
+  its end wakes you — without it reading as your answer: the sessions
+  waiting on your reply get this turn's last message as an interim one,
+  saying what you wait on, and wait on; you are not closed for being
+  done meanwhile; and the last message of the turn the job's end wakes
+  you into is the reply (hold again there to wait on more).
 work session keep <id>
   Keep a session this one started open for follow-ups, as \`new --keep\`
   would have: it is never closed for being done.
@@ -559,6 +570,19 @@ work session kill --done
             );
           return;
         }
+        case "hold": {
+          const me = sessionId(ctx);
+          const what = rest.join(" ").trim();
+          if (!what) ctx.die('usage: work session hold "<what you wait on>"');
+          const r = await ctx.api.post(`/api/sessions/${me}/hold${by()}`, {
+            what,
+          });
+          return ctx.out(r, () =>
+            console.log(
+              `held: ${r.waiting.join(", ")} ${r.waiting.length === 1 ? "gets" : "get"} this turn's last message as an interim reply and ${r.waiting.length === 1 ? "waits" : "wait"} on; the last message of the turn its end wakes you into is the reply`,
+            ),
+          );
+        }
         case "keep": {
           const [id] = rest;
           if (!id) ctx.die("usage: work session keep <id>");

package/dist/_B3vnjx9I.js

@@ -0,0 +1,2 @@
+import { J as notifySessionsChanged } from "./_Bt8-Yuz-.js";
+export { notifySessionsChanged };

package/dist/{_Cv5RrCSW.js → _Bt8-Yuz-.js}

@@ -750,6 +750,16 @@ var STEPS = [
 		up(db) {
 			db.exec("ALTER TABLE session_messages ADD COLUMN by_send INTEGER NOT NULL DEFAULT 0");
 		}
+	},
+	{
+		version: 12,
+		name: "follow-ups and held replies",
+		up(db) {
+			db.exec(`
+        ALTER TABLE session_messages ADD COLUMN follows TEXT;
+        ALTER TABLE session_messages ADD COLUMN held TEXT;
+      `);
+		}
 	}
 ];
 var LATEST = STEPS.at(-1).version;
@@ -9478,7 +9488,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("./_BKkT73fv.js").then((m) => m.notifySessionsChanged(workspaceId));
+		import("./_B3vnjx9I.js").then((m) => m.notifySessionsChanged(workspaceId));
 		return;
 	}
 	publish("sessions.changed");
@@ -12923,14 +12933,19 @@ function placeInStacks(list, names, places, wsBranch, baseBranch) {
 * compared against the base, the review would show every default-branch
 * commit since the base's own fork as the lane's. Only a fork point that
 * contains the other counts as newer, and two that do not line up (a lane
-* from the base that merged the default branch in) keep the base, as
-* does a base missing from origin (its fallbacks follow). A tie is the
-* default branch's: the lane holds none of the base's own commits, and
-* against the base a backport repeating part of the feature would look
-* already landed, an empty section, where its PR would not be. */
+* from the base that merged the default branch in) keep the base. A base
+* missing from origin leaves the default branch: the fallback after it,
+* the workspace branch's remote, holds a layer under that branch. A tie
+* is the default branch's: the lane holds none of the base's own commits,
+* and against the base a backport repeating part of the feature would
+* look already landed, an empty section, where its PR would not be. */
 async function laneParent(dir, head, baseBranch, defaultBranch) {
 	if (!defaultBranch || defaultBranch === baseBranch) return { branch: baseBranch };
 	const [onBase, onDefault] = await Promise.all([baseBranch, defaultBranch].map((b) => mergeBaseOf(dir, head, `origin/${b}`).catch(() => "")));
+	if (!onBase && onDefault) return {
+		branch: defaultBranch,
+		mergeBase: onDefault
+	};
 	if (!onBase || !onDefault) return {
 		branch: baseBranch,
 		mergeBase: onBase || void 0
@@ -13674,8 +13689,8 @@ async function repoSections(dir, ws, repo, branch, localHead, open, merged) {
 	if (!ownsBranchOf(branch, ws.branch, foreign)) return [checkout];
 	const family = await familyBranches(dir, ws, foreign);
 	if (!family.names.length) return [checkout];
-	const [places, bases] = await Promise.all([stackParents(dir, ws, repo, family, open), resolveRefs(dir, [`origin/${repo.base_branch}`])]);
-	const baseTip = bases.get(`origin/${repo.base_branch}`)?.commit;
+	const [places, bases] = await Promise.all([stackParents(dir, ws, repo, family, open), resolveRefs(dir, [`origin/${repo.base_branch}`, `origin/${repo.default_branch}`])]);
+	const baseTip = (bases.get(`origin/${repo.base_branch}`) ?? bases.get(`origin/${repo.default_branch}`))?.commit;
 	const tipOf = (name) => family.local.get(name) ?? family.remote.get(name);
 	const count = (range) => git([
 		"rev-list",
@@ -17576,7 +17591,7 @@ function notifySessionsChanged(workspaceId) {
 async function emitSessionsChanged(workspaceId) {
 	try {
 		const states = await sessionStates();
-		const { teamsOf } = await import("./_BviTiVOB.js");
+		const { teamsOf } = await import("./_CydDAvZA.js");
 		publish("sessions.changed", {
 			workspaceId,
 			sessions: listSessions(workspaceId).map((s) => ({
@@ -18236,6 +18251,26 @@ function configuredBases(bare) {
 	});
 	return bases;
 }
+/** Where a repo's work lands: its workspace branch's base, unless that is
+* one of the workspace's own branches, as when the top of a stack names
+* the layer under it so `gh pr create` bases its PR there. A layer is not
+* a base (it is not on origin until pushed, and lies above the stack's
+* bottom): each one's base is followed down to the first branch outside
+* the workspace's, else the default branch. */
+function landingBase(ws, repo, bases) {
+	let base = bases.get(ws.branch) ?? repo.base_branch;
+	let foreign;
+	const seen = /* @__PURE__ */ new Set();
+	while (ownsBranch(base, ws.branch)) {
+		foreign ??= otherWorkspaceBranches(ws.id);
+		if (!ownsBranchOf(base, ws.branch, foreign)) break;
+		const below = !seen.has(base) && bases.get(base);
+		if (!below) return repo.default_branch || base;
+		seen.add(base);
+		base = below;
+	}
+	return base;
+}
 /** A base moved: the workspace's AGENTS.md names it, and pages show it. */
 var baseMoves;
 function baseMoved() {
@@ -18261,8 +18296,8 @@ function hydrate(ws) {
 	if (ws.pending && materializeErrors.has(ws.id)) ws.pending_error = materializeErrors.get(ws.id);
 	ws.repos = all("SELECT full_name, worktree, base_branch, default_branch FROM repos WHERE workspace_id = ? ORDER BY worktree", ws.id);
 	for (const repo of ws.repos) {
-		const base = configuredBases(barePath(repo.full_name)).get(ws.branch);
-		if (!base || base === repo.base_branch) continue;
+		const base = landingBase(ws, repo, configuredBases(barePath(repo.full_name)));
+		if (base === repo.base_branch) continue;
 		db.prepare("UPDATE repos SET base_branch = ? WHERE workspace_id = ? AND full_name = ?").run(base, ws.id, repo.full_name);
 		repo.base_branch = base;
 		baseMoved();

package/dist/{_DIwr1RBh.js → _CgUfpqH_.js}

@@ -83,101 +83,101 @@ var toastTitle = {
 	warn: "_w",
 	info: "_x"
 };
-var tocDot = "_de _ba";
+var tocDot = "_c5 _ba";
 //#endregion
 //#region src/tags/settings-agents.css.ts
-var agentRow = "_eU _dK";
-var list$3 = "_dO _dw _dJ _dM";
-var metaChip = "_d2 _bz _by";
+var agentRow = "_fz _es";
+var list$3 = "_ew _dw _er _eu";
+var metaChip = "_eK _bz _by";
 var sectionCount = "_dt _bp _bq";
-var usageNote = "_ke _by";
-var pop$2 = "_hw _bN";
-var spinner = "_hz _bD _bi";
-var toolLead = "_gZ _dX";
-var name$4 = "_gT _dX";
-var desc$1 = "_gU _dY";
+var usageNote = "_kf _by";
+var pop$2 = "_go _bN";
+var spinner = "_gr _bD _bi";
+var toolLead = "_fY _eF";
+var name$4 = "_f8 _eF";
+var desc$1 = "_f9 _eG";
 //#endregion
 //#region src/tags/lsp-add-dialog.css.ts
-var addDlg = "_mh _bV";
-var key$1 = "_lQ _lO";
-var addTile = "_lS _lO";
-var field$2 = "_l3 _bA";
-var keyField = "_l4 _l3 _bA";
-var labelField = "_l5 _l3 _bA";
-var detailsToggle = "_gd _6";
-var themeSeg = "_fw _bR";
-var checkList = "_hh _du";
+var addDlg = "_lT _bX";
+var key$1 = "_lz _lx";
+var addTile = "_lB _lx";
+var field$2 = "_lM _bA";
+var keyField = "_lN _lM _bA";
+var labelField = "_lO _lM _bA";
+var detailsToggle = "_g0 _6";
+var themeSeg = "_ea _bR";
+var checkList = "_h4 _du";
 //#endregion
 //#region src/tags/prompt-dialog.css.ts
-var promptDlg = "_bZ _bV";
+var promptDlg = "_b1 _bX";
 var item$1 = "_b6 _D";
 var glance = "_dG _D";
 //#endregion
 //#region src/tags/side-nav.css.ts
-var iconBtn = "_b9 _D";
-var settingsDot = "_b_ _bQ";
-var notifyBtn = "_ce _D";
+var iconBtn = "_cn _D";
+var settingsDot = "_co _bQ";
+var notifyBtn = "_ct _D";
 //#endregion
 //#region src/styles/session-pop.css.ts
-var sessionPop = "_cg _bN";
-var sessionPopBtn = "_ch _bk";
-var wsBtn = "_e6 _bk";
-var rowIcon = "_e8 _bF _D";
-var prChip = "_lx _M _lr";
+var sessionPop = "_cl _bN";
+var sessionPopBtn = "_cm _bk";
+var wsBtn = "_fl _bk";
+var rowIcon = "_fn _bF _D";
+var prChip = "_l8 _M _l2";
 //#endregion
 //#region src/tags/port-chip.css.ts
-var port = "_oL _M _lr";
+var port = "_oI _M _l2";
 var depth = {
-	"1": "_kO",
-	"2": "_kP",
-	"3": "_kQ"
+	"1": "_kt",
+	"2": "_ku",
+	"3": "_kv"
 };
-var open = "_kW _bk";
-var action = "_k1 _bI _D";
-var toggle = "_d7 _6";
-var fold = "_d8 _dL";
+var open = "_kB _bk";
+var action = "_kG _bI _D";
+var toggle = "_eP _6";
+var fold = "_eQ _et";
 var statusOf = {
-	queued: "_mK",
-	starting: "_mL",
-	working: "_mM",
-	waiting: "_mN",
-	idle: "_mO",
-	done: "_mP",
-	closed: "_mQ"
+	queued: "_mV",
+	starting: "_mW",
+	working: "_mX",
+	waiting: "_mY",
+	idle: "_mZ",
+	done: "_m0",
+	closed: "_m1"
 };
-var item = "_kr _bk";
-var menu = "_nc _cg _bN";
-var menuItem = "_ne _bk";
-var findBtn$1 = "_jh _ih _bG _D";
-var tool = "_ih _bG _D";
-var heldRefresh = "_ip _M";
-var pop$1 = "_no _cg _bN";
-var fileFilter = "_oP _F";
-var findInput = "_ex _F";
-var keybarIconBtn = "_eG _bI _D";
-var input = "_cN _F";
-var group = "_cQ _6";
-var hint$1 = "_nz _bp _3";
+var item = "_j2 _bk";
+var menu = "_nw _cl _bN";
+var menuItem = "_ny _bk";
+var findBtn$1 = "_jc _ic _bG _D";
+var tool = "_ic _bG _D";
+var heldRefresh = "_ik _M";
+var pop$1 = "_ms _cl _bN";
+var fileFilter = "_oM _F";
+var findInput = "_dT _F";
+var keybarIconBtn = "_d2 _bI _D";
+var input = "_ca _F";
+var group = "_cd _6";
+var hint$1 = "_mz _bp _3";
 var sheetDir = "_n6 _bP";
-var upBtn = "_iC _bG _D";
-var findBtn = "_iG _ih _bG _D";
-var goBtn = "_iH _ih _bG _D";
+var upBtn = "_ix _bG _D";
+var findBtn = "_iB _ic _bG _D";
+var goBtn = "_iC _ic _bG _D";
 var note = "_mo _by";
 //#endregion
 //#region src/tags/manage-workspace.css.ts
-var procCmd = "_gE _dX";
-var factCopy = "_gL _bI _D";
-var resultRow = "_lc _bk";
-var resultBranch = "_ld _d2 _bz _by _bF _D";
-var urlAction = "_le _d2 _bz _by _d3";
-var curRow = "_gs _dR";
+var procCmd = "_hI _eF";
+var factCopy = "_hP _bI _D";
+var resultRow = "_lg _bk";
+var resultBranch = "_lh _eK _bz _by _bF _D";
+var urlAction = "_li _eK _bz _by _eL";
+var curRow = "_gf _ez";
 //#endregion
 //#region src/tags/join-dialog.css.ts
-var dlg = "_l_ _bV";
-var hint = "_ma _by";
-var kbtn = "_cD _bH _D";
-var repeat = "_cG _cF";
-var dpadUser = "_cJ _cF";
-var dpadEsc = "_cK _cF";
+var dlg = "_kM _bX";
+var hint = "_kN _by";
+var kbtn = "_cQ _bH _D";
+var repeat = "_cT _cS";
+var dpadUser = "_cW _cS";
+var dpadEsc = "_cX _cS";
 //#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/_CydDAvZA.js

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

package/dist/{_DuwPQCOE.js → _D6z2VKMF.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 "./_Cv5RrCSW.js";
+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 "./_Bt8-Yuz-.js";
 //#region src/server/messages.ts
 var team = {
 	memberGroup: () => null,
@@ -24,6 +24,8 @@ var RETRY_MS = 3e3;
 var MAX_BODY = 5e4;
 /** A reply past this is cut, pointing at the rest. */
 var MAX_REPLY = 2e4;
+/** What a held reply says it waits on is a line, not a report. */
+var MAX_HELD = 200;
 /** A pane that has written nothing for this long is a CLI at its prompt:
 * every agent's screen animates while it works (scraper.ts). */
 var PANE_STILL_MS = 4e3;
@@ -49,6 +51,12 @@ var deliveredAt = /* @__PURE__ */ new Map();
 var steered = /* @__PURE__ */ new Set();
 /** Turn ends held back from answering (`holdAnswer`), by session. */
 var held = /* @__PURE__ */ new Map();
+/** Whom each session's turn's end last answered, and when, until a
+* message goes into it or someone types into it: till then a turn of it
+* is one it started on its own, still on what it was asked
+* (`answerOwnTurn`). A restart forgets it, as agent-state forgets
+* phases. */
+var answered = /* @__PURE__ */ new Map();
 /** Sessions any row is addressed to: the scraper asks about every session
 * without a pane on every tick, so the answer for one with none is a set
 * lookup rather than a query. */
@@ -67,21 +75,26 @@ function render(row) {
 			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} "…").\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}`;
 		}
 		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}):\n\n${row.body}`;
 			const owed = row.from_session ? stillOwed(row.to_session, row.from_session) : "";
-			return `[work] Reply from session ${from}${row.answers ? ` to ${row.answers}` : ""}${owed ? `; ${owed}` : ""}. ${followUp(row.from_session ?? "<id>", row.to_session)}:\n\n${row.body}`;
+			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}` : ""}. ${followUp(row.from_session ?? "<id>", row.to_session)}:\n\n${row.body}`;
 		}
 		case "closed": return `[work] ${row.body}`;
 	}
 }
-/** A message as a reply names it: when it was sent, and how it begins. */
-function excerpt(row) {
-	const time = new Date(row.created_at).toLocaleTimeString("en-GB", {
+/** A moment as a reply names it ("14:05"). */
+function clock(at) {
+	return new Date(at).toLocaleTimeString("en-GB", {
 		hour: "2-digit",
 		minute: "2-digit"
 	});
+}
+/** A message as a reply names it: when it was sent, and how it begins. */
+function excerpt(row) {
+	const time = clock(row.created_at);
 	const line = row.body.split("\n").find((l) => l.trim())?.trim() ?? "";
 	return `${time} ("${line.length > EXCERPT ? `${line.slice(0, 39)}…` : line}")`;
 }
@@ -128,7 +141,7 @@ function groupClosing(rows) {
 * under its name. */
 function renderGroup(groupId, rows) {
 	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` : ""}. To follow up with one: work session send <id> "…"${groupClosing(rows)}`, ...rows.map((r) => `## ${r.from_label ?? r.from_session}\n\n${r.body}`)].join("\n\n");
+	return [`[work] Group "${team.groupTitle(groupId)}" (${groupId}): ${rows.length - closed} ${rows.length - closed === 1 ? "reply" : "replies"}${closed ? `, ${closed} closed before replying` : ""}. 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");
 }
 /** Rows as typed in: each on its own, a group's together where its first
 * would be. */
@@ -161,9 +174,9 @@ function senderLabel(from, to) {
 	const ws = get("SELECT name FROM workspaces WHERE id = ?", from.workspace_id);
 	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) {
-	return Number(db.prepare(`INSERT INTO session_messages (to_session, from_session, from_label, kind, body, wants_reply, group_id, answers, urgent, by_send)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(to, from?.id ?? null, from ? senderLabel(from, to) : null, kind, body, wantsReply ? 1 : 0, groupId, answers, urgent ? 1 : 0, bySend ? 1 : 0).lastInsertRowid);
+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)
+         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);
 }
 function deleteIds(ids) {
 	if (!ids.length) return;
@@ -215,6 +228,7 @@ async function deliver(id) {
 	}
 	if (keys) steered.add(id);
 	deliveredAt.set(id, Date.now());
+	answered.delete(id);
 	deleteIds(rows.filter((r) => !r.wants_reply).map((r) => r.id));
 	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')
@@ -343,7 +357,7 @@ 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));
-	db.prepare("UPDATE sessions SET answered_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now') WHERE id = ?").run(from.id);
+	noteAnswered(from.id);
 	return owed;
 }
 /** The replies (and word of sessions that closed) waiting for `me`, from
@@ -383,6 +397,10 @@ function takeReplies(me, from, any = false) {
 			label: r.from_label,
 			kind: r.kind,
 			answers: r.answers,
+			/** A follow-up: when the reply it follows went. */
+			follows: r.follows,
+			/** An interim reply: what it waits on before it answers. */
+			held: r.held,
 			/** It asks in turn: answered by this session's turn's end, or by
 			* a send back (`send`). */
 			asks: r.wants_reply ? r.by_send ? "send" : "turn" : null,
@@ -413,8 +431,8 @@ function messageStates() {
 * mid-turn, not at once (`holdAnswer`), and with what the turns folded
 * into this end said before it. */
 function answer(id, message, earlier = []) {
-	if (!mailboxes.has(id)) return false;
-	if (!steered.has(id)) return answerNow(id, message);
+	if (!mailboxes.has(id)) return answerOwnTurn(id, message);
+	if (!steered.has(id)) return answerNow(id, message) || answerOwnTurn(id, message);
 	if (!get("SELECT 1 FROM session_messages WHERE to_session = ? AND wants_reply = 1 AND by_send = 0 AND delivered_at IS NOT NULL", id)) {
 		steered.delete(id);
 		return false;
@@ -469,20 +487,102 @@ function answerNow(id, message) {
 	if (!owed.length || !session) return false;
 	const body = replyBody(session, message);
 	const group = team.memberGroup(id);
-	let told = false;
+	const held = owed.find((r) => r.held)?.held ?? null;
+	const askers = /* @__PURE__ */ new Map();
 	for (const asker of new Set(owed.map((r) => r.from_session))) {
 		const to = asker ? getSession(asker) : void 0;
 		if (!to || to.agent === "shell") continue;
-		const answers = group ? null : yours(owed.filter((r) => r.from_session === asker));
-		insert(to.id, session, "reply", body, false, group, answers);
+		const asked = owed.filter((r) => r.from_session === asker);
+		const answers = group ? null : yours(asked);
+		insert(to.id, session, "reply", body, false, group, answers, false, false, null, held);
+		askers.set(to.id, {
+			asked,
+			answers
+		});
+	}
+	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));
+		if (askers.size) {
+			answered.set(id, {
+				askers,
+				at: Date.now()
+			});
+			noteAnswered(id);
+		}
+		if (group) team.memberAnswered(id, message);
+	}
+	recompute();
+	kick();
+	return askers.size > 0;
+}
+/** `id` ends its turn under way before its work is done — a job of its
+* own runs on and wakes it as it ends — and says so (`work session
+* hold`): what it owes by its turn's end stays owed, so its askers wait
+* on, and it is not closed for being done (server/team `doneWith`), and
+* that end goes to them as an interim reply saying what it waits on. The
+* turn the job's end wakes it into answers, or holds again. Held in a
+* turn it started on its own after answering (`answerOwnTurn`), it owes
+* its askers again what they had asked. Returns who waits on it. */
+function holdReply(id, what) {
+	if (!getSession(id)) throw httpError(404, `no session ${id}`);
+	const waits = what.trim().replace(/\s+/g, " ").slice(0, MAX_HELD) || "a job of its own";
+	const bySend = get("SELECT 1 FROM session_messages WHERE to_session = ? AND wants_reply = 1 AND by_send = 1 AND delivered_at IS NOT NULL", id);
+	let held = db.prepare("UPDATE session_messages SET held = ? WHERE to_session = ? AND wants_reply = 1 AND by_send = 0 AND delivered_at IS NOT NULL").run(waits, id).changes;
+	const last = answered.get(id);
+	if (!held && last && lastTypedAt(id) <= last.at) {
+		for (const [asker, { asked }] of last.askers) {
+			const from = getSession(asker);
+			if (!from || from.agent === "shell") continue;
+			for (const row of asked) db.prepare(`INSERT INTO session_messages (to_session, from_session, from_label, kind, body, wants_reply, created_at, delivered_at, held)
+           VALUES (?, ?, ?, 'message', ?, 1, ?, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'), ?)`).run(id, asker, senderLabel(from, id), row.body, row.created_at, waits);
+			held++;
+		}
+		answered.delete(id);
+	}
+	if (!held) throw httpError(409, bySend ? `${id} answers by a send (\`work session send <id> "…"\`, as its header says): send it once the work is done` : `nobody waits on a reply from ${id}: there is nothing to hold`);
+	recompute();
+	return {
+		waiting: all("SELECT DISTINCT from_session AS id FROM session_messages WHERE to_session = ? AND held IS NOT NULL AND from_session IS NOT NULL", id).map((r) => r.id),
+		held: waits
+	};
+}
+/** A turn the session started on its own since its turn's end answered
+* (nothing went into it, nobody typed into it): what it was asked, still
+* — the job it ended that turn to wait on has ended, a wakeup it set has
+* come — so its last message goes to the same askers as a follow-up, and
+* again for each such turn after. Whatever woke it, the CLI's turn end
+* is all this reads, so it is the same for every agent. A follow-up
+* leaves a group alone: its member answered when its reply went. */
+function answerOwnTurn(id, message) {
+	const last = answered.get(id);
+	const session = getSession(id);
+	if (!last || !session || !message) return false;
+	if (lastTypedAt(id) > last.at) {
+		answered.delete(id);
+		return false;
+	}
+	const body = replyBody(session, message);
+	const follows = new Date(last.at).toISOString();
+	let told = false;
+	for (const [asker, { answers }] of last.askers) {
+		const to = getSession(asker);
+		if (!to || to.agent === "shell") continue;
+		insert(to.id, session, "reply", body, false, null, answers, false, false, follows);
 		told = true;
 	}
-	deleteIds(owed.map((r) => r.id));
-	if (told) db.prepare("UPDATE sessions SET answered_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now') WHERE id = ?").run(id);
-	if (group) team.memberAnswered(id, message);
+	if (!told) {
+		answered.delete(id);
+		return false;
+	}
+	last.at = Date.now();
+	noteAnswered(id);
 	recompute();
 	kick();
-	return told;
+	return true;
+}
+function noteAnswered(id) {
+	db.prepare("UPDATE sessions SET answered_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now') WHERE id = ?").run(id);
 }
 /** The session's process is gone, or the session is: whoever waits on it
 * for a reply is told none is coming, and what was queued for it goes —
@@ -490,6 +590,7 @@ function answerNow(id, message) {
 function settle(id, why) {
 	dropHold(id);
 	steered.delete(id);
+	answered.delete(id);
 	const session = getSession(id);
 	const label = session ? labelOf(session) : id;
 	const group = team.memberGroup(id);
@@ -964,4 +1065,4 @@ function startTeam() {
 	kickPool();
 }
 //#endregion
-export { takeReplies as _, keepSession as a, retryMember as c, teamOf as d, teamsOf as f, startMessages as g, sessionGone as h, createGroup as i, skipMember as l, sendMessage as m, closeDone as n, kickPool as o, messageStates as p, closeFinished as r, memberWorkspace as s, clearGroup as t, startTeam as u };
+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 };