@dylanpiercey/work 0.2.56 → 0.2.58

package/dist/_DWusAO29.js

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

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

@@ -1,4 +1,4 @@
-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";
+import { $ as renameSession, A as closedSession, Bn as onTurnFailed, Cn as agentPhase, E as agentCaller, En as hookReportedAt, Fr as getSetting, Ir as isKnownAgent, J as notifySessionsChanged, Jn as turnPhase, L as getSession, Ln as onFinished, On as lastTypedAt, Qn as agentFamily, R as interruptSession, Rn as onPhaseChange, Sn as activityOf, U as listPanesWithin, Un as setExpecting, Vn as sessionWatched, Xn as turnSince, Y as onSessionDispose, Yn as turnSettling, dn as quotesPastes, er as agentLabel, et as reopenSession, fi as all, it as sendToSession, j as createSession, kr as agentChoices, mi as get, mn as steerKeys, nt as restartSession, oi as httpError, pi as db, qn as summaryOf, rt as retireSession, tt as reopenable, un as interruptKeys, yn as cleanSummary, z as killSession, zn as onTurnEnd } from "./_4NlHgkKA.js";
 //#region src/server/messages.ts
 var team = {
 	memberGroup: () => null,
@@ -61,6 +61,10 @@ var failedTold = /* @__PURE__ */ new Map();
 var repliedAt = /* @__PURE__ */ new Map();
 /** Sessions a message went into mid-turn, until a turn's end answers it. */
 var steered = /* @__PURE__ */ new Set();
+/** Whom each held session has told that its reply is held, since it last
+* answered or they last wrote to it (`answerNow`): its next held end
+* tells them nothing new. A restart forgets it, as it forgets typing. */
+var heldTold = /* @__PURE__ */ new Map();
 /** 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
@@ -101,7 +105,7 @@ function render(row, roll) {
 		}
 		case "reply": {
 			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}` : ""}:`,
+				head: `[work] Interim reply from session ${from}${row.answers ? ` to ${row.answers}` : ""}: it is not done, it waits on ${row.held}, and its reply is the next you hear from it (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("; ");
@@ -371,6 +375,7 @@ async function deliver(id) {
 	deliveredAt.set(id, Date.now());
 	if (rows.some((r) => r.kind !== "message")) repliedAt.set(id, Date.now());
 	answered.delete(id);
+	for (const r of rows) if (r.kind === "message" && r.from_session) heldTold.get(id)?.delete(r.from_session);
 	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);
@@ -422,7 +427,9 @@ function kick() {
 * 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, or
 * the user's own session's send back (`by_send`), which a send from it
-* to an asker it owes is (`answerBySend`).
+* to an asker it owes is (`answerBySend`). From its lead to a session
+* that owes nobody a reply it wants one whatever `reply` says
+* (`replyAnyway`).
 * `opts.now` sends it into the turn under way where its CLI takes one
 * there, as one from an agent that wants no reply goes, and
 * `opts.interrupt` stops that turn first (never a wait on the user:
@@ -451,7 +458,8 @@ async function sendMessage(to, text, opts = {}) {
 	let target = live;
 	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 = queued.length ? queued.some((r) => r.wants_reply) : !!from && opts.reply !== false;
+	const replyAnyway = !queued.length && opts.reply === false && !!from && target.parent_id === from.id && !get("SELECT 1 FROM session_messages WHERE to_session = ? AND kind = 'message' AND wants_reply = 1", to);
+	const wantsReply = queued.length ? queued.some((r) => r.wants_reply) : !!from && (opts.reply !== false || replyAnyway);
 	const bySend = wantsReply && !target.parent_id;
 	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;
@@ -459,7 +467,7 @@ async function sendMessage(to, text, opts = {}) {
 	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);
+	} else id = insert(to, from, "message", text, wantsReply, null, answered.length ? yours(answered) : null, urgent || !!from && opts.reply === false, bySend);
 	recompute();
 	const interrupted = !!opts.interrupt && !!live && turnPhase(to) === "working" && !delivering.has(to) && await interruptSession(to);
 	const sent = await deliver(to);
@@ -488,6 +496,9 @@ async function sendMessage(to, text, opts = {}) {
 		steers: !!steerKeys(target.agent),
 		interrupts: !!interruptKeys(target.agent),
 		wantsReply,
+		/** Sent wanting none, it wants its reply: the sender's own session,
+		* owing nobody one, would end the turn this starts unheard. */
+		replyAnyway,
 		/** It answers with a send back, not its turn's last message. */
 		bySend,
 		/** Its messages this answers (`answerBySend`). */
@@ -677,20 +688,30 @@ function answerNow(id, message) {
 	const body = replyBody(session, message);
 	const group = team.memberGroup(id);
 	const held = owed.find((r) => r.held)?.held ?? null;
+	const told = heldTold.get(id) ?? /* @__PURE__ */ new Set();
 	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 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) {
+			const unread = all("SELECT id FROM session_messages WHERE to_session = ? AND from_session = ? AND kind = 'reply' AND held IS NOT NULL AND delivered_at IS NULL", to.id, id).map((r) => r.id);
+			if (!unread.length && told.has(to.id)) continue;
+			deleteIds(unread, "replaced by a later interim reply");
+			told.add(to.id);
+		}
+		insert(to.id, session, "reply", body, false, group, answers, false, false, null, held);
 	}
-	if (held) db.prepare(`UPDATE session_messages SET held = NULL WHERE id IN (${owed.map(() => "?").join(",")})`).run(...owed.map((r) => r.id));
-	else {
+	if (held) {
+		heldTold.set(id, told);
+		db.prepare(`UPDATE session_messages SET held = NULL WHERE id IN (${owed.map(() => "?").join(",")})`).run(...owed.map((r) => r.id));
+	} else {
+		heldTold.delete(id);
 		deleteIds(owed.map((r) => r.id), "answered");
 		if (askers.size) {
 			answered.set(id, {
@@ -780,6 +801,7 @@ function settle(id, why) {
 	dropHold(id);
 	steered.delete(id);
 	answered.delete(id);
+	heldTold.delete(id);
 	repliedAt.delete(id);
 	failedTold.delete(id);
 	const session = getSession(id);