@dylanpiercey/work 0.2.29 → 0.2.31

package/dist/{_cvaVxDgR.js → _DAiB3S3K.js}

@@ -1,4 +1,4 @@
-import { $ as reopenable, A as closedSession, An as onTurnEnd, H as listPanesWithin, J as onSessionDispose, Jr as httpError, L as getSession, Ln as summaryOf, Nn as setExpecting, On as onFinished, Q as reopenSession, R as killSession, Rn as turnPhase, Tr as isKnownAgent, Un as agentLabel, Z as renameSession, bn as lastTypedAt, dn as cleanSummary, ei as all, et as retireSession, hn as agentPhase, j as createSession, jn as sessionWatched, kn as onPhaseChange, mn as activityOf, ni as get, q as notifySessionsChanged, ti as db, tt as sendToSession, vn as hookReportedAt, wr as getSetting, zn as turnSettling } from "./_DQbVrULO.js";
+import { $ as reopenSession, A as closedSession, Bn as summaryOf, Cn as lastTypedAt, Hn as turnSettling, In as setExpecting, J as notifySessionsChanged, L as getSession, Mn as onPhaseChange, Nn as onTurnEnd, Or as getSetting, Pn as sessionWatched, Q as renameSession, Qr as httpError, R as interruptSession, U as listPanesWithin, Un as turnSince, Vn as turnPhase, Y as onSessionDispose, _n as activityOf, ai as db, et as reopenable, ii as all, j as createSession, jn as onFinished, kr as isKnownAgent, ln as steerKeys, mn as cleanSummary, nt as sendToSession, oi as get, on as interruptKeys, qn as agentLabel, tt as retireSession, vn as agentPhase, xn as hookReportedAt, z as killSession } from "./_Chg81Eud.js";
 //#region src/server/messages.ts
 var team = {
 	memberGroup: () => null,
@@ -24,6 +24,14 @@ var RETRY_MS = 3e3;
 var MAX_BODY = 5e4;
 /** A reply past this is cut, pointing at the rest. */
 var MAX_REPLY = 2e4;
+/** 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;
+/** How often a held answer looks at the pane again. */
+var HOLD_POLL_MS = 1e3;
+/** A held answer goes after this however its pane looks: a CLI that
+* paints at its prompt would otherwise hold it forever. */
+var HOLD_MAX_MS = 6e5;
 /** How much of a message's first line a reply quotes to name it. */
 var EXCERPT = 40;
 /** A pane just started for a message can be missing from a pane list
@@ -37,6 +45,10 @@ var sends = /* @__PURE__ */ new Map();
 /** Recipients a delivery is typing into right now. */
 var delivering = /* @__PURE__ */ new Set();
 var deliveredAt = /* @__PURE__ */ new Map();
+/** Sessions a message went into mid-turn, until a turn's end answers it. */
+var steered = /* @__PURE__ */ new Set();
+/** Turn ends held back from answering (`holdAnswer`), by session. */
+var held = /* @__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. */
@@ -144,9 +156,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) {
-	return Number(db.prepare(`INSERT INTO session_messages (to_session, from_session, from_label, kind, body, wants_reply, group_id, answers)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(to, from?.id ?? null, from ? senderLabel(from, to) : null, kind, body, wantsReply ? 1 : 0, groupId, answers).lastInsertRowid);
+function insert(to, from, kind, body, wantsReply = false, groupId = null, answers = null, urgent = false) {
+	return Number(db.prepare(`INSERT INTO session_messages (to_session, from_session, from_label, kind, body, wants_reply, group_id, answers, urgent)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(to, from?.id ?? null, from ? senderLabel(from, to) : null, kind, body, wantsReply ? 1 : 0, groupId, answers, urgent ? 1 : 0).lastInsertRowid);
 }
 function deleteIds(ids) {
 	if (!ids.length) return;
@@ -174,30 +186,36 @@ function admit(sender) {
 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). */
+/** Type what is queued for `id` into it, if it is at its prompt, or into
+* its turn under way if any of it is to go now and its CLI takes that.
+* Returns why not (`waits`), or nothing once it is typed in (or there was
+* nothing), and whether that was mid-turn. */
 async function deliver(id) {
-	if (delivering.has(id)) return "another message is being typed in";
+	if (delivering.has(id)) return { waits: "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";
+	if (phase === "waiting") return { waits: "it is waiting on the user" };
+	if (turnSettling(id)) return { waits: "it is working" };
 	const rows = deliverable(id);
-	if (!rows.length) return void 0;
+	const keys = phase === "working" && rows.some((r) => r.urgent) ? steerKeys(getSession(id)?.agent) : void 0;
+	if (phase === "working" && !keys) return { waits: "it is working" };
+	if (Date.now() - lastTypedAt(id) < TYPING_QUIET_MS) return { waits: "someone is typing in its terminal" };
+	if (!rows.length) return {};
 	delivering.add(id);
 	try {
-		await sendToSession(id, renderAll(rows));
+		await sendToSession(id, renderAll(rows), void 0, keys);
 	} catch (err) {
-		return err.message;
+		return { waits: err.message };
 	} finally {
 		delivering.delete(id);
 	}
+	if (keys) steered.add(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();
+	return { midTurn: !!keys };
 }
 var pumping = false;
 var again = false;
@@ -241,6 +259,9 @@ function kick() {
 * 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.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).
 * `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 = {}) {
@@ -267,19 +288,35 @@ async function sendMessage(to, text, opts = {}) {
 	}
 	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);
+	const ahead = get("SELECT COUNT(*) AS n FROM session_messages WHERE to_session = ? AND delivered_at IS NULL", to)?.n ?? 0;
+	const id = insert(to, from, "message", text, wantsReply, null, null, !!(opts.now || opts.interrupt));
 	recompute();
-	const hold = await deliver(to);
+	const interrupted = !!opts.interrupt && !!live && turnPhase(to) === "working" && !delivering.has(to) && await interruptSession(to);
+	const sent = await deliver(to);
 	const row = get("SELECT delivered_at FROM session_messages WHERE id = ?", id);
-	if (row && !row.delivered_at) kick();
+	const waits = !!row && !row.delivered_at;
+	if (waits) kick();
+	const since = waits ? turnSince(to) : void 0;
 	return {
 		to: {
 			id: target.id,
 			agent: target.agent,
 			title: target.title
 		},
-		delivered: !row || !!row.delivered_at,
-		queued: row && !row.delivered_at ? hold ?? "queued" : null,
+		delivered: !waits,
+		queued: waits ? sent.waits ?? "queued" : null,
+		/** Typed into the turn under way: its CLI hands it over at the turn's
+		* next step. */
+		midTurn: !!sent.midTurn,
+		/** Its turn was stopped for it. */
+		interrupted,
+		/** While it waits: how long the turn it waits out has run (ms), and
+		* how many messages sent before it wait with it. */
+		turnMs: since === void 0 ? null : Date.now() - since,
+		ahead: waits ? ahead : 0,
+		/** What `now` and `interrupt` can do with this session's CLI. */
+		steers: !!steerKeys(target.agent),
+		interrupts: !!interruptKeys(target.agent),
 		wantsReply,
 		/** It had closed, and is back on its conversation. */
 		reopened: !live
@@ -340,9 +377,60 @@ function messageStates() {
 }
 /** 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) {
+* group. Once a message went in 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 (!get("SELECT 1 FROM session_messages WHERE to_session = ? AND wants_reply = 1 AND delivered_at IS NOT NULL", id)) {
+		steered.delete(id);
+		return false;
+	}
+	for (const said of earlier) holdAnswer(id, said);
+	holdAnswer(id, message);
+	return true;
+}
+/** A message that goes in mid-turn as the agent writes its answer is, to
+* some CLIs (Claude, opencode, Copilot), not that turn's: it runs as a
+* turn of its own straight after, which no hook announces, and that
+* turn's end is the answer to it. A CLI at work keeps painting and one at
+* its prompt goes still, so a turn's end answers once its pane has gone
+* still with no turn begun. A turn that begins takes it over: its end
+* answers, after the held turn's message, so the asker reads what the
+* agent said before it took the message and what it did with it. */
+function holdAnswer(id, message) {
+	const hold = held.get(id) ?? {
+		messages: [],
+		look: 0
+	};
+	held.set(id, hold);
+	hold.messages.push(message);
+	const since = Date.now();
+	const schedule = (ms) => {
+		clearTimeout(hold.timer);
+		const n = ++hold.look;
+		hold.timer = setTimeout(() => void look(n), ms);
+		hold.timer.unref?.();
+	};
+	const look = async (n) => {
+		if (held.get(id) !== hold || hold.look !== n) return;
+		if (turnPhase(id) || turnSettling(id)) return;
+		const panes = await listPanesWithin(HOLD_POLL_MS);
+		if (held.get(id) !== hold || hold.look !== n) return;
+		const pane = panes?.find((p) => p.id === id);
+		if ((pane ? Date.now() - pane.activityAt : Infinity) < PANE_STILL_MS && Date.now() - since < HOLD_MAX_MS) return schedule(HOLD_POLL_MS);
+		held.delete(id);
+		const said = hold.messages.filter((m) => !!m);
+		answerNow(id, said.length ? said.join("\n\n") : void 0);
+	};
+	schedule(PANE_STILL_MS);
+}
+function dropHold(id) {
+	clearTimeout(held.get(id)?.timer);
+	held.delete(id);
+}
+function answerNow(id, message) {
+	steered.delete(id);
 	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;
@@ -367,6 +455,8 @@ function answer(id, message) {
 * 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) {
+	dropHold(id);
+	steered.delete(id);
 	const session = getSession(id);
 	const label = session ? labelOf(session) : id;
 	const group = team.memberGroup(id);

package/dist/_ENzyVrzA.js

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