@dylanpiercey/work 0.2.19 → 0.2.20

package/dist/_C9c_BxRk.js

@@ -0,0 +1,787 @@
+import { C as sendToSession, F as activityOf, I as agentPhase, Mt as getSetting, Nt as isKnownAgent, Q as sessionWatched, S as renameSession, V as lastTypedAt, X as onPhaseChange, Y as onFinished, Z as onTurnEnd, _n as all, at as turnPhase, b as onSessionDispose, d as killSession, dn as httpError, et as setExpecting, h as listPanesWithin, i as createSession, it as summaryOf, j as cleanSummary, ot as turnSettling, u as getSession, ut as agentLabel, vn as db, y as notifySessionsChanged, yn as get, z as hookReportedAt } from "./_Hb3LeA5Q.js";
+//#region src/server/messages.ts
+var team = {
+	memberGroup: () => null,
+	groupReleased: () => true,
+	groupTitle: (id) => id,
+	waitingOwners: () => [],
+	openGroups: () => [],
+	memberAnswered: () => {},
+	memberGone: () => {}
+};
+function setTeamHooks(hooks) {
+	team = hooks;
+}
+/** Someone typed into the recipient's terminal this recently: what they
+* are writing is in its input box, where a paste would join it and the
+* Enter after it send both. */
+var TYPING_QUIET_MS = 2e4;
+/** How often a queue that is waiting looks again: typing that stopped, a
+* startup question answered, a kick that found the session mid-change. */
+var RETRY_MS = 3e3;
+/** A message is a request, not a document: a file says more for less. */
+var MAX_BODY = 5e4;
+/** A reply past this is cut, pointing at the rest. */
+var MAX_REPLY = 2e4;
+/** 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;
+/** 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;
+var MAX_SENDS = 40;
+var sends = /* @__PURE__ */ new Map();
+/** Recipients a delivery is typing into right now. */
+var delivering = /* @__PURE__ */ new Set();
+var deliveredAt = /* @__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. */
+var mailboxes = /* @__PURE__ */ new Set();
+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. */
+function render(row) {
+	const from = row.from_label ?? row.from_session;
+	switch (row.kind) {
+		case "message":
+			if (!row.from_session) return row.body;
+			return row.wants_reply ? `[work] From session ${from}: 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}` : `[work] From session ${from}, no reply needed:\n\n${row.body}`;
+		case "reply": return `[work] Reply from session ${from} (to follow up: work session send ${row.from_session} "…"):\n\n${row.body}`;
+		case "closed": return `[work] ${row.body}`;
+	}
+}
+/** A group's replies as one: a head saying how many, then each member's
+* 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> "…"`, ...rows.map((r) => `## ${r.from_label ?? r.from_session}\n\n${r.body}`)].join("\n\n");
+}
+/** Rows as typed in: each on its own, a group's together where its first
+* would be. */
+function renderAll(rows) {
+	const out = [];
+	const done = /* @__PURE__ */ new Set();
+	for (const row of rows) {
+		if (!row.group_id) {
+			out.push(render(row));
+			continue;
+		}
+		if (done.has(row.group_id)) continue;
+		done.add(row.group_id);
+		const members = rows.filter((r) => r.group_id === row.group_id);
+		out.push(members.length > 1 || team.groupReleased(row.group_id) ? renderGroup(row.group_id, members) : render(row));
+	}
+	return out.join("\n\n");
+}
+function replyBody(session, message) {
+	const tab = `/w/${session.workspace_id}?s=${session.id}`;
+	if (!message) return `(Its CLI reports no last message: see its tab, ${tab})`;
+	if (message.length <= MAX_REPLY) return message;
+	return `${message.slice(0, MAX_REPLY)}\n\n[cut at ${MAX_REPLY} characters: the rest is in its tab, ${tab}]`;
+}
+function insert(to, from, kind, body, wantsReply = false, groupId = null) {
+	return Number(db.prepare(`INSERT INTO session_messages (to_session, from_session, from_label, kind, body, wants_reply, group_id)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`).run(to, from?.id ?? null, from ? labelOf(from) : null, kind, body, wantsReply ? 1 : 0, groupId).lastInsertRowid);
+}
+function deleteIds(ids) {
+	if (!ids.length) return;
+	db.prepare(`DELETE FROM session_messages WHERE id IN (${ids.map(() => "?").join(",")})`).run(...ids);
+}
+/** 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
+* ones have no session to owe it anything yet. */
+function recompute() {
+	setExpecting(/* @__PURE__ */ new Set([...all(`SELECT from_session AS id FROM session_messages
+           WHERE wants_reply = 1 AND from_session IS NOT NULL
+         UNION SELECT to_session FROM session_messages WHERE delivered_at IS NULL`).map((r) => r.id), ...team.waitingOwners()]));
+	mailboxes = new Set(all("SELECT DISTINCT to_session AS id FROM session_messages").map((r) => r.id));
+}
+function admit(sender) {
+	const now = Date.now();
+	const times = (sends.get(sender) || []).filter((t) => now - t < SEND_WINDOW_MS);
+	if (times.length >= MAX_SENDS) throw httpError(429, `${MAX_SENDS} messages in ${SEND_WINDOW_MS / 6e4} minutes is the most from one session: wait ${Math.ceil((SEND_WINDOW_MS - (now - times[0])) / 6e4)} min`);
+	times.push(now);
+	sends.set(sender, times);
+}
+/** What is queued for `id` and may go now: a held group's replies wait
+* for the rest of their group. */
+function deliverable(id) {
+	return all("SELECT * FROM session_messages WHERE to_session = ? AND delivered_at IS NULL ORDER BY id", id).filter((r) => !r.group_id || team.groupReleased(r.group_id));
+}
+/** Type what is queued for `id` into it, if it is at its prompt. Returns
+* why not, or undefined once it is typed in (or there was nothing). */
+async function deliver(id) {
+	if (delivering.has(id)) return "another message is being typed in";
+	const phase = turnPhase(id);
+	if (phase === "waiting") return "it is waiting on the user";
+	if (phase === "working" || turnSettling(id)) return "it is working";
+	if (Date.now() - lastTypedAt(id) < TYPING_QUIET_MS) return "someone is typing in its terminal";
+	const rows = deliverable(id);
+	if (!rows.length) return void 0;
+	delivering.add(id);
+	try {
+		await sendToSession(id, renderAll(rows));
+	} catch (err) {
+		return err.message;
+	} finally {
+		delivering.delete(id);
+	}
+	deliveredAt.set(id, Date.now());
+	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')
+       WHERE id IN (${owed.map(() => "?").join(",")})`).run(...owed);
+	recompute();
+}
+var pumping = false;
+var again = false;
+var retry = null;
+/** Deliver to every running session with something queued. Never starts
+* a session: only a sender's own request does that (`sendMessage`). */
+async function pump() {
+	if (pumping) {
+		again = true;
+		return;
+	}
+	pumping = true;
+	try {
+		for (let i = 0; i < 5; i++) {
+			again = false;
+			const queued = all("SELECT DISTINCT to_session AS id FROM session_messages WHERE delivered_at IS NULL").map((r) => r.id).filter((id) => deliverable(id).length);
+			if (!queued.length) break;
+			const panes = await listPanesWithin(2e3);
+			if (!panes) break;
+			const running = new Set(panes.map((p) => p.id));
+			for (const id of queued) if (running.has(id)) await deliver(id);
+			if (!again) break;
+		}
+	} finally {
+		pumping = false;
+		const waiting = all("SELECT DISTINCT to_session AS id FROM session_messages WHERE delivered_at IS NULL").some((r) => deliverable(r.id).length);
+		if (!retry && waiting) {
+			retry = setTimeout(() => {
+				retry = null;
+				pump();
+			}, RETRY_MS);
+			retry.unref?.();
+		}
+	}
+}
+/** Look at the queues now (a group finished: its replies may go). */
+function kick() {
+	pump().catch((err) => console.error(`[work] messages: ${err.message}`));
+}
+/** A message from `opts.from` (a session id; none: the user's own
+* terminal) to session `to`, typed in now if it is at its prompt, else
+* queued until it is. From an agent's session it wants a reply unless
+* `reply` is false: the recipient's last message as that turn ends.
+* `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 target = getSession(to);
+	if (!target) throw httpError(404, `no session ${to}`);
+	if (target.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");
+	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 && !opts.member) admit(from.id);
+	if (!from && target.parent_id) db.prepare("UPDATE sessions SET keep = 1 WHERE id = ?").run(to);
+	const wantsReply = !!from && opts.reply !== false;
+	const id = insert(to, from, "message", text, wantsReply);
+	recompute();
+	const hold = await deliver(to);
+	const row = get("SELECT delivered_at FROM session_messages WHERE id = ?", id);
+	if (row && !row.delivered_at) kick();
+	return {
+		to: {
+			id: target.id,
+			agent: target.agent,
+			title: target.title
+		},
+		delivered: !row || !!row.delivered_at,
+		queued: row && !row.delivered_at ? hold ?? "queued" : null,
+		wantsReply
+	};
+}
+/** The replies (and word of sessions that closed) waiting for `me`, from
+* the sessions or groups `from` names or anyone, taken so they are not
+* typed in too; and who still owes `me` one. A group's replies are taken
+* once all of them are in, unless `any`: then as each comes. `work
+* session wait` asks this until nobody owes it anything. */
+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' AND delivered_at IS NULL ORDER BY id", me).filter(wanted).filter((r) => any || !r.group_id || team.groupReleased(r.group_id));
+	deleteIds(rows.map((r) => r.id));
+	const groups = team.openGroups(me);
+	const inGroup = new Set(groups.map((g) => g.id));
+	const owing = all(`SELECT DISTINCT m.to_session AS id, gm.group_id FROM session_messages m
+     LEFT JOIN group_members gm ON gm.session_id = m.to_session AND gm.state = 'running'
+     WHERE m.from_session = ? AND m.wants_reply = 1`, me).filter((r) => !r.group_id || !inGroup.has(r.group_id)).filter((r) => !from?.length || from.includes(r.id)).map((r) => {
+		const s = getSession(r.id);
+		return {
+			id: r.id,
+			label: s ? labelOf(s) : r.id
+		};
+	});
+	for (const g of groups) if (!from?.length || from.includes(g.id)) owing.push({
+		id: g.id,
+		label: `group "${g.title}"`
+	});
+	if (rows.length) recompute();
+	return {
+		replies: rows.map((r) => ({
+			from: r.from_session,
+			group: r.group_id,
+			label: r.from_label,
+			kind: r.kind,
+			text: r.body
+		})),
+		owing
+	};
+}
+/** Per session with any: the sessions it waits on for a reply, and how
+* many messages wait to be typed into it. */
+function messageStates() {
+	const states = /* @__PURE__ */ new Map();
+	const of = (id) => {
+		let s = states.get(id);
+		if (!s) states.set(id, s = {
+			waitingOn: [],
+			queued: 0
+		});
+		return s;
+	};
+	for (const r of all("SELECT DISTINCT from_session, to_session FROM session_messages WHERE wants_reply = 1 AND from_session IS NOT NULL")) of(r.from_session).waitingOn.push(r.to_session);
+	for (const r of all("SELECT to_session AS id, COUNT(*) AS n FROM session_messages WHERE delivered_at IS NULL GROUP BY to_session")) of(r.id).queued = r.n;
+	return states;
+}
+/** A turn's end answers what the session was asked: its last message
+* goes to each session that asked, as a reply — a member's held for its
+* group. */
+function answer(id, message) {
+	if (!mailboxes.has(id)) return false;
+	const owed = all("SELECT * FROM session_messages WHERE to_session = ? AND wants_reply = 1 AND delivered_at IS NOT NULL", id);
+	const session = getSession(id);
+	if (!owed.length || !session) return false;
+	const body = replyBody(session, message);
+	const group = team.memberGroup(id);
+	let told = false;
+	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;
+		insert(to.id, session, "reply", body, false, group);
+		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);
+	recompute();
+	kick();
+	return told;
+}
+/** 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 —
+* a reply means nothing to the process that next runs there. */
+function settle(id, why) {
+	const session = getSession(id);
+	const label = session ? labelOf(session) : id;
+	const group = team.memberGroup(id);
+	const askers = all("SELECT DISTINCT from_session AS id FROM session_messages WHERE to_session = ? AND wants_reply = 1 AND from_session IS NOT NULL", id).map((r) => r.id);
+	for (const asker of askers) {
+		const to = getSession(asker);
+		if (to && to.id !== id && to.agent !== "shell") insert(to.id, session ?? null, "closed", `Session ${label} ${why}`, false, group);
+	}
+	db.prepare("DELETE FROM session_messages WHERE to_session = ?").run(id);
+	if (group) team.memberGone(id);
+	recompute();
+	kick();
+}
+/** 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;
+	settle(id, "exited before it replied.");
+}
+var started$1 = false;
+function startMessages() {
+	if (started$1) return;
+	started$1 = true;
+	onTurnEnd(answer);
+	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);
+		db.prepare("UPDATE session_messages SET wants_reply = 0 WHERE from_session = ?").run(id);
+		recompute();
+	});
+	recompute();
+	kick();
+}
+//#endregion
+//#region src/server/team.ts
+/** A group's members at most: past it, a fan-out is a sweep that wants
+* the agent's own in-process subagents, not a CLI each. */
+var MAX_MEMBERS = 64;
+/** Members one lead may have queued, every group's together: a lead
+* fanning out in a loop meets it long before the queue is a problem. */
+var MAX_QUEUED = 128;
+var MAX_PARALLEL = 16;
+var DEFAULT_PARALLEL = 4;
+/** Boots at once, whatever the pool allows running. */
+var MAX_BOOTING = 2;
+/** A pool with queued members looks again this often, for a slot that a
+* session freed without a hook to say so. */
+var POOL_RETRY_MS = 5e3;
+/** Lines a plan keeps of its log. */
+var MAX_LOG = 200;
+/** A finished group older than this goes as the server starts. */
+var PRUNE_AFTER = "-1 day";
+var now = () => (/* @__PURE__ */ new Date()).toISOString();
+var newId = (prefix) => `${prefix}${Math.random().toString(36).slice(2, 9)}`;
+/** The machine's cap on members running at once, every group's together
+* (Settings, `team-max-running`). */
+function maxRunning() {
+	const n = Number(getSetting("ui.team-max-running"));
+	return Number.isInteger(n) && n > 0 ? n : 6;
+}
+function groupOf(id) {
+	return get("SELECT * FROM session_groups WHERE id = ?", id);
+}
+function membersOf(groupId) {
+	return all("SELECT * FROM group_members WHERE group_id = ? ORDER BY ord", groupId);
+}
+function memberBySession(sessionId) {
+	return get("SELECT * FROM group_members WHERE session_id = ? ORDER BY attempts DESC LIMIT 1", sessionId);
+}
+function changed(workspaceId) {
+	if (workspaceId) notifySessionsChanged(workspaceId);
+}
+/** 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);
+}
+/** Start a fan-out of `owner`'s: its members, queued, and the pool told. */
+function createGroup(owner, input) {
+	const lead = getSession(owner);
+	if (!lead?.workspace_id) throw httpError(404, `no session ${owner}`);
+	if (lead.agent === "shell") throw httpError(409, "a fan-out is run by an agent's session: its members' replies go back to it");
+	const agents = [...new Set(input.agents.filter(Boolean))];
+	if (!agents.length) throw httpError(400, "a fan-out needs an --agent");
+	for (const a of agents) if (!isKnownAgent(a) || a === "shell") throw httpError(400, `no agent ${a} here (\`work agent\` lists them)`);
+	const items = (input.items ?? []).map((i) => i.trim()).filter(Boolean);
+	const count = Math.max(1, Math.floor(input.count ?? 1));
+	const slots = [];
+	for (const agent of agents) if (items.length) for (const item of items) slots.push({
+		agent,
+		item,
+		n: 0
+	});
+	else for (let n = 1; n <= count; n++) slots.push({
+		agent,
+		item: null,
+		n
+	});
+	if (slots.length > MAX_MEMBERS) throw httpError(400, `${slots.length} members is more than ${MAX_MEMBERS}: a sweep that wide is a job for your CLI's own subagents`);
+	const queued = get(`SELECT COUNT(*) AS n FROM group_members m JOIN session_groups g ON g.id = m.group_id
+     WHERE g.owner = ? AND m.state = 'queued'`, owner).n;
+	if (queued + slots.length > MAX_QUEUED) throw httpError(429, `${queued} members are already queued for this session: let them start (or skip some) before fanning out more`);
+	const dirs = input.dirs ?? [];
+	if (dirs.length && dirs.length !== slots.length) throw httpError(400, `${dirs.length} folders for ${slots.length} members`);
+	const title = input.title.trim() || "fan-out";
+	const parallel = Math.min(MAX_PARALLEL, Math.max(1, Math.floor(input.parallel ?? DEFAULT_PARALLEL)));
+	const current = openPlan(owner);
+	const id = newId("g");
+	db.prepare(`INSERT INTO session_groups (id, workspace_id, owner, plan_id, phase, title, parallel, fan_in, close_done, keep)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, lead.workspace_id, owner, current?.id ?? null, input.phase?.trim() || null, title, parallel, input.fanIn === false ? 0 : 1, input.closeDone ? 1 : 0, input.keep ? 1 : 0);
+	const several = new Set(slots.map((p) => p.agent)).size > 1;
+	const insert = db.prepare(`INSERT INTO group_members (id, group_id, ord, agent, title, prompt, launch_dir)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`);
+	slots.forEach((p, i) => {
+		const name = p.item ?? (slots.length > agents.length ? `#${p.n}` : "");
+		const who = several ? p.agent : "";
+		const memberTitle = [title, [name, who].filter(Boolean).join(" ")].filter(Boolean).join(" · ").slice(0, 60);
+		const prompt = input.prompt.replaceAll("{}", p.item ?? "").replaceAll("{i}", String(i + 1));
+		insert.run(newId("m"), id, i + 1, p.agent, memberTitle, prompt, dirs[i] ?? null);
+	});
+	recompute();
+	changed(lead.workspace_id);
+	kickPool();
+	return groupView(groupOf(id));
+}
+/** Rerun a member that closed: a fresh session with the same prompt. Its
+* lead's word that it closed is taken back, so the group waits for it. */
+function retryMember(memberId) {
+	const m = get("SELECT * FROM group_members WHERE id = ?", memberId);
+	if (!m) throw httpError(404, `no member ${memberId}`);
+	if (m.state !== "closed") throw httpError(409, `${m.title} is ${m.state}: only a closed one reruns`);
+	const g = groupOf(m.group_id);
+	if (m.session_id) db.prepare("DELETE FROM session_messages WHERE group_id = ? AND from_session = ? AND kind = 'closed' AND delivered_at IS NULL").run(g.id, m.session_id);
+	db.prepare("UPDATE group_members SET state = 'queued', session_id = NULL, note = NULL, summary = NULL, done_at = NULL WHERE id = ?").run(memberId);
+	recompute();
+	changed(g.workspace_id);
+	kickPool();
+}
+/** Stop a member: a queued one never starts, a running one's session is
+* closed (with whatever it started), and either counts as answered. */
+async function skipMember(memberId) {
+	const m = get("SELECT * FROM group_members WHERE id = ?", memberId);
+	if (!m) throw httpError(404, `no member ${memberId}`);
+	const g = groupOf(m.group_id);
+	if (m.state === "queued") {
+		db.prepare("UPDATE group_members SET state = 'closed', note = 'skipped', done_at = ? WHERE id = ?").run(now(), memberId);
+		released(g);
+	} else if (m.state === "running" && m.session_id) {
+		db.prepare("UPDATE group_members SET note = 'skipped' WHERE id = ?").run(memberId);
+		await killSession(m.session_id);
+	}
+	changed(g.workspace_id);
+}
+/** Close the sessions of a group's members that have answered: their
+* results are kept, their CLIs no longer hold memory. */
+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 killSession(m.session_id);
+	changed(g.workspace_id);
+	return done.length;
+}
+/** 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`);
+	await closeDone(groupId);
+	db.prepare("DELETE FROM session_groups WHERE id = ?").run(groupId);
+	changed(g.workspace_id);
+}
+/** A group whose last member just answered or closed: its held replies
+* may go, and its lead stops waiting on it. */
+function released(g) {
+	recompute();
+	if (!open(g.id)) kick();
+	kickPool();
+}
+var booting = /* @__PURE__ */ new Set();
+var pooling = false;
+var poolAgain = false;
+var poolRetry = null;
+function kickPool() {
+	pool().catch((err) => console.error(`[work] team: ${err.message}`));
+}
+async function pool() {
+	if (pooling) {
+		poolAgain = true;
+		return;
+	}
+	pooling = true;
+	try {
+		do {
+			poolAgain = false;
+			const running = all("SELECT group_id, COUNT(*) AS n FROM group_members WHERE state = 'running' GROUP BY group_id");
+			const perGroup = new Map(running.map((r) => [r.group_id, r.n]));
+			let free = maxRunning() - running.reduce((n, r) => n + r.n, 0);
+			if (free <= 0) break;
+			const queued = all(`SELECT m.*, g.parallel FROM group_members m JOIN session_groups g ON g.id = m.group_id
+         WHERE m.state = 'queued' ORDER BY g.created_at, m.ord`);
+			for (const m of queued) {
+				if (free <= 0 || booting.size >= MAX_BOOTING) break;
+				const n = perGroup.get(m.group_id) ?? 0;
+				if (n >= m.parallel) continue;
+				perGroup.set(m.group_id, n + 1);
+				free--;
+				db.prepare("UPDATE group_members SET state = 'running', attempts = attempts + 1, started_at = ?, note = NULL WHERE id = ? AND state = 'queued'").run(now(), m.id);
+				booting.add(m.id);
+				start(m).finally(() => {
+					booting.delete(m.id);
+					kickPool();
+				});
+			}
+		} while (poolAgain);
+	} finally {
+		pooling = false;
+		if (get("SELECT 1 AS x FROM group_members WHERE state = 'queued'") && !poolRetry) {
+			poolRetry = setTimeout(() => {
+				poolRetry = null;
+				kickPool();
+			}, POOL_RETRY_MS);
+			poolRetry.unref?.();
+		}
+	}
+}
+/** A member's session: made under its lead, named, and handed its prompt
+* as a message from the lead, which starts its CLI. */
+async function start(m) {
+	const g = groupOf(m.group_id);
+	const lead = g ? getSession(g.owner) : void 0;
+	if (!g || !lead?.workspace_id) {
+		db.prepare("UPDATE group_members SET state = 'closed', note = 'its lead is gone', done_at = ? WHERE id = ?").run(now(), m.id);
+		return;
+	}
+	let sessionId = null;
+	try {
+		const session = createSession(lead.workspace_id, m.agent, false, {
+			parent: lead.id,
+			launchDir: m.launch_dir,
+			keep: !!g.keep
+		});
+		sessionId = session.id;
+		renameSession(session.id, m.title);
+		db.prepare("UPDATE group_members SET session_id = ? WHERE id = ?").run(session.id, m.id);
+		const sent = await sendMessage(session.id, m.prompt, {
+			from: lead.id,
+			reply: true,
+			member: true
+		});
+		if (!sent.delivered) db.prepare("UPDATE group_members SET note = ? WHERE id = ?").run(sent.queued, m.id);
+	} catch (err) {
+		const why = err.message;
+		if (!sessionId || !getSession(sessionId)) {
+			db.prepare("UPDATE group_members SET state = 'closed', note = ?, done_at = ? WHERE id = ?").run(why, now(), m.id);
+			released(g);
+		} else db.prepare("UPDATE group_members SET note = ? WHERE id = ?").run(why, m.id);
+	}
+	changed(lead.workspace_id);
+}
+setTeamHooks({
+	memberGroup(sessionId) {
+		const m = memberBySession(sessionId);
+		return m?.state === "running" ? m.group_id : null;
+	},
+	groupReleased(groupId) {
+		const g = groupOf(groupId);
+		return !g || !g.fan_in || !open(groupId);
+	},
+	groupTitle(groupId) {
+		return groupOf(groupId)?.title ?? groupId;
+	},
+	waitingOwners() {
+		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);
+	},
+	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 killSession(sessionId), 0);
+		released(g);
+		changed(g.workspace_id);
+	},
+	memberGone(sessionId) {
+		const m = memberBySession(sessionId);
+		if (!m || m.state !== "running") return;
+		db.prepare("UPDATE group_members SET state = 'closed', note = COALESCE(note, 'closed before it replied'), done_at = ? WHERE id = ?").run(now(), m.id);
+		const g = groupOf(m.group_id);
+		released(g);
+		changed(g.workspace_id);
+	}
+});
+function openPlan(owner) {
+	return get("SELECT * FROM plans WHERE owner = ? AND done_at IS NULL ORDER BY created_at DESC LIMIT 1", owner);
+}
+/** A lead's plan: the phases its groups fall under, in order. A new one
+* ends the lead's last. */
+function createPlan(owner, name, phases) {
+	const lead = getSession(owner);
+	if (!lead?.workspace_id) throw httpError(404, `no session ${owner}`);
+	if (!name.trim()) throw httpError(400, "a plan needs a name");
+	db.prepare("UPDATE plans SET done_at = ? WHERE owner = ? AND done_at IS NULL").run(now(), owner);
+	const id = newId("p");
+	const clean = phases.map((p) => ({
+		title: p.title.trim(),
+		detail: p.detail?.trim() || void 0
+	})).filter((p) => p.title);
+	db.prepare("INSERT INTO plans (id, workspace_id, owner, name, phases) VALUES (?, ?, ?, ?, ?)").run(id, lead.workspace_id, owner, name.trim(), JSON.stringify(clean));
+	changed(lead.workspace_id);
+	return planView(get("SELECT * FROM plans WHERE id = ?", id));
+}
+/** A line of what the lead is doing, over its plan's phases. */
+function logPlan(owner, text) {
+	const plan = openPlan(owner);
+	if (!plan) throw httpError(409, "no plan to log to: start one with `work plan new \"<name>\"`");
+	db.prepare("INSERT INTO plan_log (plan_id, text) VALUES (?, ?)").run(plan.id, text.trim().slice(0, 300));
+	db.prepare(`DELETE FROM plan_log WHERE plan_id = ? AND id NOT IN
+       (SELECT id FROM plan_log WHERE plan_id = ? ORDER BY id DESC LIMIT ${MAX_LOG})`).run(plan.id, plan.id);
+	changed(plan.workspace_id);
+}
+function finishPlan(owner) {
+	const plan = openPlan(owner);
+	if (!plan) throw httpError(409, "no plan under way");
+	db.prepare("UPDATE plans SET done_at = ? WHERE id = ?").run(now(), plan.id);
+	changed(plan.workspace_id);
+}
+function memberStatus(m, alive) {
+	if (m.state !== "running") return m.state;
+	if (booting.has(m.id) || !m.session_id) return "starting";
+	if (alive && !alive.has(m.session_id)) return "starting";
+	const phase = agentPhase(m.session_id);
+	if (phase === "waiting") return "waiting";
+	if (hookReportedAt(m.session_id) === void 0 && m.note) return "waiting";
+	if (turnPhase(m.session_id) === "working" || turnSettling(m.session_id)) return "working";
+	if (phase === "working") return "working";
+	return hookReportedAt(m.session_id) === void 0 ? "working" : "idle";
+}
+function memberView(m, alive) {
+	const status = memberStatus(m, alive);
+	const live = m.session_id ? getSession(m.session_id) : void 0;
+	const line = status === "done" ? m.summary : status === "working" && m.session_id ? activityOf(m.session_id) ?? live?.summary ?? null : status === "waiting" && m.session_id ? summaryOf(m.session_id) ?? m.note ?? null : m.note ?? live?.summary ?? null;
+	return {
+		id: m.id,
+		title: m.title,
+		agent: m.agent,
+		session: m.session_id,
+		status,
+		line,
+		dir: m.launch_dir,
+		attempts: m.attempts,
+		startedAt: m.started_at,
+		doneAt: m.done_at
+	};
+}
+function groupView(g, alive = null) {
+	const members = membersOf(g.id).map((m) => memberView(m, alive));
+	const counts = {
+		queued: 0,
+		starting: 0,
+		working: 0,
+		waiting: 0,
+		idle: 0,
+		done: 0,
+		closed: 0
+	};
+	for (const m of members) counts[m.status]++;
+	return {
+		id: g.id,
+		title: g.title,
+		phase: g.phase,
+		parallel: g.parallel,
+		fanIn: !!g.fan_in,
+		closeDone: !!g.close_done,
+		open: open(g.id),
+		createdAt: g.created_at,
+		counts,
+		members
+	};
+}
+function planView(p) {
+	let phases = [];
+	try {
+		phases = JSON.parse(p.phases);
+	} catch {}
+	return {
+		id: p.id,
+		name: p.name,
+		phases,
+		log: all("SELECT text, at FROM plan_log WHERE plan_id = ? ORDER BY id DESC LIMIT 5", p.id).reverse(),
+		done: !!p.done_at,
+		createdAt: p.created_at
+	};
+}
+/** Every lead's team in a workspace: its plan (the open one, else its
+* last) and its groups. */
+async function teamsOf(workspaceId) {
+	const panes = await listPanesWithin(2e3);
+	const alive = panes ? new Set(panes.flatMap((p) => p.id ? [p.id] : [])) : null;
+	const groups = all("SELECT * FROM session_groups WHERE workspace_id = ? ORDER BY created_at", workspaceId);
+	const plans = all(`SELECT * FROM plans p WHERE workspace_id = ? AND created_at =
+       (SELECT MAX(created_at) FROM plans WHERE owner = p.owner)`, workspaceId);
+	return [.../* @__PURE__ */ new Set([...groups.map((g) => g.owner), ...plans.map((p) => p.owner)])].map((owner) => {
+		const plan = plans.find((p) => p.owner === owner);
+		return {
+			owner,
+			plan: plan ? planView(plan) : null,
+			groups: groups.filter((g) => g.owner === owner).map((g) => groupView(g, alive))
+		};
+	});
+}
+/** The groups `owner` runs, for `work session team`. */
+async function teamOf(owner) {
+	const s = getSession(owner);
+	if (!s?.workspace_id) throw httpError(404, `no session ${owner}`);
+	return (await teamsOf(s.workspace_id)).find((t) => t.owner === owner) ?? {
+		owner,
+		plan: null,
+		groups: []
+	};
+}
+/** A child that answered and has sat idle this long closes: nobody is
+* 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;
+	}
+	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. */
+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());
+	let closed = 0;
+	for (const s of rows) {
+		if (!doneWith(s)) continue;
+		await killSession(s.id);
+		closed++;
+	}
+	return closed;
+}
+/** Reaps asked for while one runs: leads whose job finished meanwhile
+* (`""` is the idle sweep), each run once, in turn. */
+var toReap = /* @__PURE__ */ new Set();
+var reaping = false;
+function reap(parent = "") {
+	toReap.add(parent);
+	if (reaping) return;
+	reaping = true;
+	(async () => {
+		while (toReap.size) {
+			const next = toReap.values().next().value;
+			toReap.delete(next);
+			await closeFinished(next || void 0).catch((err) => console.error(`[work] team: ${err.message}`));
+		}
+	})().finally(() => {
+		reaping = false;
+	});
+}
+var started = false;
+function startTeam() {
+	if (started) return;
+	started = true;
+	onTurnEnd((id, message) => {
+		if (!message) return false;
+		const line = cleanSummary(message);
+		if (line) db.prepare("UPDATE sessions SET summary = ? WHERE id = ?").run(line, id);
+		return false;
+	});
+	db.prepare(`DELETE FROM session_groups WHERE created_at < strftime('%Y-%m-%dT%H:%M:%fZ', 'now', '${PRUNE_AFTER}')
+       AND id NOT IN (SELECT group_id FROM group_members WHERE state IN ('queued', 'running'))
+       AND id NOT IN (SELECT group_id FROM session_messages WHERE group_id IS NOT NULL)`).run();
+	onFinished((id) => reap(id));
+	setInterval(() => reap(), REAP_EVERY_MS).unref?.();
+	recompute();
+	kickPool();
+}
+//#endregion
+export { startMessages as _, createPlan as a, logPlan as c, startTeam as d, teamOf as f, sessionGone as g, sendMessage as h, createGroup as i, retryMember as l, messageStates as m, closeDone as n, finishPlan as o, teamsOf as p, closeFinished as r, kickPool as s, clearGroup as t, skipMember as u, takeReplies as v };