@dylanpiercey/work 0.2.53 → 0.2.55

package/dist/{_ByxSq8zO.js → _Cb_JPQ7K.js}

@@ -758,6 +758,67 @@ var STEPS = [
 			db.exec(`
         ALTER TABLE session_messages ADD COLUMN follows TEXT;
         ALTER TABLE session_messages ADD COLUMN held TEXT;
+      `);
+		}
+	},
+	{
+		version: 13,
+		name: "closes kept, and notices",
+		up(db) {
+			db.exec(`
+        ALTER TABLE closed_sessions ADD COLUMN how TEXT NOT NULL DEFAULT 'done';
+
+        CREATE TABLE session_messages_new (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          to_session TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+          from_session TEXT,
+          from_label TEXT,
+          kind TEXT NOT NULL CHECK (kind IN ('message', 'reply', 'closed', 'notice')),
+          body TEXT NOT NULL,
+          wants_reply INTEGER NOT NULL DEFAULT 0,
+          created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+          delivered_at TEXT,
+          group_id TEXT REFERENCES session_groups(id) ON DELETE SET NULL,
+          answers TEXT,
+          urgent INTEGER NOT NULL DEFAULT 0,
+          by_send INTEGER NOT NULL DEFAULT 0,
+          follows TEXT,
+          held TEXT
+        );
+        INSERT INTO session_messages_new (id, to_session, from_session, from_label, kind, body, wants_reply, created_at, delivered_at, group_id, answers, urgent, by_send, follows, held)
+          SELECT id, to_session, from_session, from_label, kind, body, wants_reply, created_at, delivered_at, group_id, answers, urgent, by_send, follows, held FROM session_messages;
+        DROP TABLE session_messages;
+        ALTER TABLE session_messages_new RENAME TO session_messages;
+        CREATE INDEX session_messages_to ON session_messages(to_session);
+        CREATE INDEX session_messages_from ON session_messages(from_session);
+      `);
+		}
+	},
+	{
+		version: 14,
+		name: "message log",
+		up(db) {
+			db.exec(`
+        CREATE TABLE message_log (
+          id INTEGER PRIMARY KEY,
+          workspace_id TEXT,
+          to_session TEXT NOT NULL,
+          to_label TEXT,
+          from_session TEXT,
+          from_label TEXT,
+          kind TEXT NOT NULL,
+          body TEXT NOT NULL,
+          wants_reply INTEGER NOT NULL DEFAULT 0,
+          urgent INTEGER NOT NULL DEFAULT 0,
+          created_at TEXT NOT NULL,
+          delivered_at TEXT,
+          delivered TEXT,
+          done_at TEXT,
+          outcome TEXT
+        );
+        CREATE INDEX message_log_to ON message_log(to_session);
+        CREATE INDEX message_log_from ON message_log(from_session);
+        CREATE INDEX message_log_workspace ON message_log(workspace_id, created_at);
       `);
 		}
 	}
@@ -2027,6 +2088,61 @@ function unreachableText(host, why) {
 	return `Can't reach ${host} (${why}): connect to its network or VPN`;
 }
 //#endregion
+//#region lib/setup/shims.mjs
+/** Version managers whose shims stand in for a tool. A shim is the
+* manager's own binary (mise links every shim to itself) or a script that
+* hands off to it, so neither its path nor its target is the install: the
+* manager's `which` names that. A tool removed from its manager leaves the
+* shim until a reshim. `installs` and `reshim` are a node global's, which
+* is what work's own install is. */
+function versionManagers() {
+	return [
+		{
+			id: "mise",
+			shim: (file, real) => path.basename(real) === "mise",
+			which: (real, name) => [real, ["which", name]],
+			installs: /\/mise\/installs\/node\//,
+			reshim: "mise reshim"
+		},
+		{
+			id: "asdf",
+			shim: (file) => /\/\.asdf\/shims$/.test(path.dirname(file)),
+			which: (real, name) => ["asdf", ["which", name]],
+			installs: /\/\.asdf\/installs\/nodejs\//,
+			reshim: "asdf reshim nodejs"
+		},
+		{
+			id: "nodenv",
+			shim: (file) => /\/\.nodenv\/shims$/.test(path.dirname(file)),
+			which: (real, name) => ["nodenv", ["which", name]],
+			installs: /\/\.nodenv\/versions\//,
+			reshim: "nodenv rehash"
+		}
+	];
+}
+/** What the shim at `file` runs: the path its manager names; null when it
+* names none (the tool is gone, or no version of it is set), so the shim
+* runs nothing; undefined when `file` is no shim, or its manager could not
+* be asked (missing, hung), since unknown is not gone. Asked from the home
+* folder: the answer for a folder with no config of its own, wherever this
+* process was started. */
+function shimTarget(file, name = path.basename(file)) {
+	let real = file;
+	try {
+		real = fs.realpathSync(file);
+	} catch {}
+	const manager = versionManagers().find((m) => m.shim(file, real));
+	if (!manager) return void 0;
+	const [bin, argv] = manager.which(real, name);
+	const out = spawnSync(bin, argv, {
+		encoding: "utf8",
+		timeout: 2e3,
+		cwd: os.homedir()
+	});
+	if (out.error || out.status === null) return void 0;
+	return out.status === 0 && out.stdout.trim() || null;
+}
+//#endregion
 //#region lib/setup/doctor.mjs
 var home$1 = os.homedir();
 /** Agent CLI install dirs from meta (`~` → home). Same list the service and
@@ -2211,14 +2327,29 @@ function discoverAgents(fresh = false) {
 		}
 		return agentsMemo.value;
 	}
-	const value = scanAgents();
+	const value = scanAgents(fresh);
 	agentsMemo = {
 		at: Date.now(),
 		value
 	};
 	return value;
 }
-function scanAgents() {
+/** Whether each shim found had nothing behind it, by path. Asking its
+* manager is a process (about 30 ms) inside a synchronous scan, so an
+* answer serves five minutes of them; a `fresh` scan asks again. */
+var SHIM_MEMO_MS = 3e5;
+var shimMemo = /* @__PURE__ */ new Map();
+function deadShim(file, name, fresh) {
+	const kept = shimMemo.get(file);
+	if (!fresh && kept && Date.now() - kept.at < SHIM_MEMO_MS) return kept.dead;
+	const dead = shimTarget(file, name) === null;
+	shimMemo.set(file, {
+		at: Date.now(),
+		dead
+	});
+	return dead;
+}
+function scanAgents(fresh = false) {
 	const dirs = setupDirs();
 	const seenDirs = /* @__PURE__ */ new Set();
 	const seen = /* @__PURE__ */ new Map();
@@ -2246,6 +2377,7 @@ function scanAgents() {
 			} catch {
 				continue;
 			}
+			if (deadShim(full, name, fresh)) continue;
 			const bin = hit.bins.find((b) => name.startsWith(b));
 			seen.set(name, {
 				family: hit,
@@ -9277,6 +9409,17 @@ function noteBackground(sessionId, work) {
 function onTurnEnd(fn) {
 	turnEndListeners.add(fn);
 }
+/** Told of a turn that ended failing (rate limited, signed out), with
+* why (`onTurnFailed`). */
+var failedListeners = /* @__PURE__ */ new Set();
+/** A session's turn ended failing, as its hook said (`HookRead.failed`):
+* it sits at its prompt until someone carries it on. */
+function onTurnFailed(fn) {
+	failedListeners.add(fn);
+}
+function noteTurnFailed(sessionId, why) {
+	for (const fn of failedListeners) fn(sessionId, why);
+}
 function endTurn(sessionId) {
 	const earlier = foldedMessages.get(sessionId) ?? [];
 	foldedMessages.delete(sessionId);
@@ -9488,7 +9631,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("./_DMIGXpem.js").then((m) => m.notifySessionsChanged(workspaceId));
+		import("./_CVNGN2QO.js").then((m) => m.notifySessionsChanged(workspaceId));
 		return;
 	}
 	publish("sessions.changed");
@@ -10219,9 +10362,12 @@ function readHook$6(p, reported, _state) {
 	if (event === "StopFailure") {
 		const label = FAILURES[str$1(p.error)] ?? "The turn failed";
 		const details = str$1(p.error_details);
+		const summary = cleanSummary(details ? `${label}: ${details}` : label);
 		return {
 			reason: "attention",
-			summary: cleanSummary(details ? `${label}: ${details}` : label)
+			summary,
+			failed: str$1(p.agent_id) ? void 0 : summary,
+			conversation: str$1(p.session_id) || void 0
 		};
 	}
 	const read = readClaudeStyle(p, reported);
@@ -10237,8 +10383,8 @@ function readHook$6(p, reported, _state) {
 	} else if (event === "Stop") {
 		const running = backgroundWork(p);
 		if (running) read.background = { running };
-		read.conversation = str$1(p.session_id) || void 0;
 	}
+	if (event === "Stop" || event === "UserPromptSubmit") read.conversation = str$1(p.session_id) || void 0;
 	return read;
 }
 /** The kinds of `background_tasks` entry Claude wakes up for as they end
@@ -10318,6 +10464,8 @@ var claude = {
 	headless: (args) => hasArg(args, "-p", "--print"),
 	resumeFlags: (id) => ["--resume", id],
 	steerKeys: ["Enter"],
+	submitsBehindPaste: true,
+	quotesPastes: true,
 	interruptKeys: ["Escape"],
 	envPrefixes: ["CLAUDE", "AI_AGENT"],
 	startupQuestions: [{
@@ -10545,6 +10693,7 @@ var codex = {
 	launchFlags,
 	resumeFlags: (id) => ["resume", id],
 	steerKeys: ["Enter"],
+	submitsBehindPaste: true,
 	interruptKeys: ["Escape"],
 	reportsWorking: () => true,
 	headless: (args) => hasArg(args, "exec", "e", "review"),
@@ -10812,6 +10961,7 @@ var copilot = {
 	}],
 	reportsWorking: () => true,
 	steerKeys: ["Enter"],
+	submitsBehindPaste: true,
 	interruptKeys: ["C-c"],
 	headless: (args) => hasArg(args, "-p", "--prompt"),
 	envPrefixes: ["COPILOT_"],
@@ -11291,6 +11441,7 @@ var grok = {
 	},
 	reportsWorking: registered,
 	promptAsArgv: true,
+	submitsBehindPaste: true,
 	interruptKeys: ["C-c"],
 	headless: (args) => hasArg(args, "-p", "--single", "--prompt-file", "--prompt-json", "agent"),
 	envPrefixes: ["GROK_"],
@@ -11469,6 +11620,7 @@ var opencode = {
 	launchEnv: () => ({ OPENCODE_CONFIG_CONTENT: pluginConfig() }),
 	reportsWorking: installed$1,
 	steerKeys: ["Enter"],
+	submitsBehindPaste: true,
 	interruptKeys: ["Escape", "Escape"],
 	headless: (args) => hasArg(args, "run"),
 	envPrefixes: ["OPENCODE_"],
@@ -11485,7 +11637,10 @@ var meta = meta_default;
 * prompt, the one way Pi stops on the user. A Pi older than
 * `agent_settled` (0.80.4) never sends it, so a run's end waits a moment
 * for one and reports itself when none comes. The extension posts its own
-* reports, as opencode's plugin does; `readHook` only unwraps them. */
+* reports, as opencode's plugin does; `readHook` only unwraps them. It
+* also answers Pi's folder-trust question (`project_trust`, which only a
+* user's or a command-line extension is asked): a flag would do
+* (`--approve`), but a Pi from before the question exits on it. */
 var EXTENSION = (host, appPort) => `// Generated by work. Reports this
 // session's working / needs-input / done state to the app; edits are
 // overwritten. Port and session id come from the env tmux gave the pane.
@@ -11544,6 +11699,10 @@ export default function (pi) {
     if (ctx?.isIdle && !ctx.isIdle()) return;
     return settle();
   });
+  // A workspace is the user's own folder, made to run agents in: trusted
+  // for this run, never remembered. Left to ask, Pi opens on a menu that
+  // takes a first prompt's paste, whose Enter then picks its answer.
+  pi.on("project_trust", () => ({ trusted: "yes" }));
   pi.on("ui_prompt_start", (event) =>
     post("waiting", "attention", event?.title || "Waiting for input"),
   );
@@ -11592,6 +11751,7 @@ var AGENTS = [
 		launchFlags: () => ["-e", extensionFile()],
 		reportsWorking: installed,
 		steerKeys: ["Enter"],
+		submitsBehindPaste: true,
 		interruptKeys: ["Escape"],
 		headless: (args) => hasArg(args, "-p", "--print", "--mode"),
 		envPrefixes: ["PI_"],
@@ -11654,6 +11814,14 @@ function interruptKeys(id) {
 function promptAsArgv(id) {
 	return agentFor(id)?.promptAsArgv ?? false;
 }
+/** The keys that send a paste may go with it (`submitsBehindPaste`). */
+function submitsBehindPaste(id) {
+	return agentFor(id)?.submitsBehindPaste ?? false;
+}
+/** A message's head is typed ahead of its paste (`quotesPastes`). */
+function quotesPastes(id) {
+	return agentFor(id)?.quotesPastes ?? false;
+}
 /** Whether an instance's CLI, run with these arguments, is a one-shot
 * job rather than a session (`headless`). */
 function runsHeadless(id, args) {
@@ -17423,79 +17591,159 @@ function renameSession(id, title) {
 }
 /** Close a session, and with it every session it started and theirs
 * (`parent_id`), unless `keepChildren`: those then stand on their own.
-* Returns the ids closed. */
-async function killSession(id, keepChildren = false) {
+* Each that can be resumed is kept as it was (`keepClosed`): the session
+* itself as `how` says, the ones it started as closed with it, so a lead
+* the user closes, or one whose account ran out, does not take its
+* team's conversations with it. Returns the ids closed. */
+async function killSession(id, keepChildren = false, how = "closed") {
 	const session = getSession(id);
 	if (!session) return [];
 	const family = keepChildren ? [id] : [id, ...descendantsOf(id)];
-	for (const member of family) await disposeSession(member);
+	db.prepare(`DELETE FROM closed_sessions WHERE closed_at < strftime('%Y-%m-%dT%H:%M:%fZ', 'now', '${REOPEN_WITHIN}')`).run();
+	for (const member of family) {
+		keepClosed(member, member === id ? how : "closed");
+		await disposeSession(member);
+	}
 	notifySessionsChanged(session.workspace_id);
 	return family;
 }
-/** How long a session closed for being done can be reopened: a lead's
-* follow-ups come as the user reviews its result, the same day or so. */
+/** How long a closed session can be started again: a lead's follow-ups
+* come as the user reviews its result, the same day or so. */
 var REOPEN_WITHIN = "-7 days";
 /** A turn's end reported the conversation it ran in. */
 function noteConversation(id, conversation) {
 	db.prepare("UPDATE sessions SET conversation = ? WHERE id = ? AND conversation IS NOT ?").run(conversation, id, conversation);
 }
-/** A session work closed for being done, while a message may reopen it. */
+/** A closed session that can still be started again (`reopenSession`). */
 function closedSession(id) {
 	return get(`SELECT * FROM closed_sessions WHERE id = ?
        AND closed_at >= strftime('%Y-%m-%dT%H:%M:%fZ', 'now', '${REOPEN_WITHIN}')`, id);
 }
-/** Whether a message reopens the session on its conversation once work
-* has closed it: its CLI can resume one, and said which it was in. */
+/** Whether a session can be started again on its conversation: its CLI
+* can resume one, and said which it was in. */
 function reopenable(s) {
 	return !!s.conversation && canResume(s.agent);
 }
+/** Keep `id` as it is in closed_sessions, about to close. One closed for
+* being done is kept whatever it is, so a message to it can say why it
+* does not reopen; any other only if it can be started again. */
+function keepClosed(id, how) {
+	const s = getSession(id);
+	if (!s?.workspace_id || how === "closed" && !reopenable(s)) return;
+	db.prepare(`INSERT OR REPLACE INTO closed_sessions (id, workspace_id, agent, title, parent_id, launch_dir, launch_mode, summary, conversation, created_at, how)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(s.id, s.workspace_id, s.agent, s.title, s.parent_id, s.launch_dir, s.launch_mode, s.summary, s.conversation, s.created_at, how);
+}
 /** Close a session work is done with (server/team), keeping what starts
 * it again on its own conversation (`reopenSession`): the lead that
 * started it may yet follow up, once the user has read its result. The
 * sessions it started go with it, as with any close. */
-async function retireSession(id) {
-	const s = getSession(id);
-	if (!s) return [];
-	db.prepare(`DELETE FROM closed_sessions WHERE closed_at < strftime('%Y-%m-%dT%H:%M:%fZ', 'now', '${REOPEN_WITHIN}')`).run();
-	if (s.workspace_id) db.prepare(`INSERT OR REPLACE INTO closed_sessions (id, workspace_id, agent, title, parent_id, launch_dir, launch_mode, summary, conversation, created_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(s.id, s.workspace_id, s.agent, s.title, s.parent_id, s.launch_dir, s.launch_mode, s.summary, s.conversation, s.created_at);
-	return killSession(id);
-}
-/** Start a session work closed for being done again, for a message to
-* it: its row as it was (under its parent, while that is here) and its
-* CLI on the conversation it had (`resumeFlags`), ready for the message
-* before this returns. Refuses, saying what to do instead, one that
-* cannot be: its CLI cannot resume, work never learned its conversation,
-* or the folder it ran in (a topic's worktree) is gone — a conversation
-* is its folder's to Claude. */
-async function reopenSession(id) {
+function retireSession(id) {
+	return killSession(id, false, "done");
+}
+var START_AGAIN = `start a new session (\`work session new\`) and brief it; \`--keep\` keeps one open for follow-ups`;
+/** The instance a session starts again as: its own, or `agent`, another
+* instance of the same CLI (claude2 for claude: another account), whose
+* resume takes the same conversation where that is shared. */
+function resumeAs(id, current, agent) {
+	if (!agent || agent === current) return current;
+	if (!isKnownAgent(agent) || agentFamily(agent) !== agentFamily(current)) throw httpError(409, `${id} ran ${agentLabel(current)}: it resumes only on another instance of the same CLI (\`work agent\` lists them), not ${agent}`);
+	return agent;
+}
+/** Start a closed session again on the conversation it had: its row as it
+* was, as `agent` if given (`resumeAs`), under the session that started
+* it while that is here, else under `adopt` (the session reopening it, of
+* the same workspace), and its CLI on that conversation (`resumeFlags`),
+* ready for a message before this returns. Refuses, saying what to do
+* instead, one that cannot be: its CLI cannot resume, work never learned
+* its conversation, or the folder it ran in (a topic's worktree) is gone
+* — a conversation is its folder's to Claude. */
+async function reopenSession(id, opts = {}) {
 	const closed = closedSession(id);
 	if (!closed) throw httpError(404, `no session ${id}`);
-	const instead = `start a new session (\`work session new\`) and brief it; \`--keep\` keeps one open for follow-ups`;
-	if (!reopenable(closed)) throw httpError(409, `${id} closed once it was done with, and ${canResume(closed.agent) ? "work never learned its conversation" : `${agentLabel(closed.agent)} cannot be reopened on its conversation`}: ${instead}`);
+	if (!reopenable(closed)) throw httpError(409, `${id} closed once it was done with, and ${canResume(closed.agent) ? "work never learned its conversation" : `${agentLabel(closed.agent)} cannot be reopened on its conversation`}: ${START_AGAIN}`);
+	const agent = resumeAs(id, closed.agent, opts.agent);
 	const ws = get("SELECT path, status FROM workspaces WHERE id = ?", closed.workspace_id);
 	if (!ws || ws.status !== "active") throw httpError(409, `${id}'s workspace is archived`);
-	if (closed.launch_dir && launchDir(closed, ws.path) === ws.path) throw httpError(409, `${id} ran in ${closed.launch_dir}, which is gone, and its conversation with it: ${instead}`);
-	const parent = closed.parent_id ? getSession(closed.parent_id) : void 0;
+	if (closed.launch_dir && launchDir(closed, ws.path) === ws.path) throw httpError(409, `${id} ran in ${closed.launch_dir}, which is gone, and its conversation with it: ${START_AGAIN}`);
+	const parent = [closed.parent_id, opts.adopt].map((p) => p && p !== id ? getSession(p) : void 0).find((p) => p?.workspace_id === closed.workspace_id);
 	db.prepare(`INSERT INTO sessions (id, workspace_id, agent, title, created_at, parent_id, launch_dir, launch_mode, summary, conversation)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(closed.id, closed.workspace_id, closed.agent, closed.title, closed.created_at, parent?.workspace_id === closed.workspace_id ? parent.id : null, closed.launch_dir, closed.launch_mode, closed.summary, closed.conversation);
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(closed.id, closed.workspace_id, agent, closed.title, closed.created_at, parent?.id ?? null, closed.launch_dir, closed.launch_mode, closed.summary, closed.conversation);
 	const session = getSession(id);
 	const env = cleanEnv();
 	await ensureTmuxServer();
 	clearAgentPhase(id);
 	await launchDetached(session, ws.path, env, { resume: closed.conversation });
-	if (!await tmux([
-		"has-session",
-		"-t",
-		tmuxName(id)
-	], env).then(() => true, () => false)) {
-		await killSession(id);
-		throw httpError(409, `${id}'s ${agentLabel(closed.agent)} could not reopen its conversation (${closed.conversation}): ${instead}`);
+	if (!await paneAlive(id, env)) {
+		await disposeSession(id);
+		throw httpError(409, `${id}'s ${agentLabel(agent)} could not reopen its conversation (${closed.conversation})${agent === closed.agent ? "" : `: ${agent} may keep its conversations apart from ${closed.agent}'s`}. ${START_AGAIN.replace(/^./, (c) => c.toUpperCase())}`);
 	}
 	db.prepare("DELETE FROM closed_sessions WHERE id = ?").run(id);
 	notifySessionsChanged(closed.workspace_id);
 	return session;
 }
+/** Start a running session's CLI again on its own conversation, as
+* `agent` if given (`resumeAs`): one stuck at its prompt because its
+* account hit a limit goes on as another account's. Its row, what is
+* queued for it and what it owes stay (server/messages keeps them). */
+async function restartSession(id, agent) {
+	const s = getSession(id);
+	if (!s) throw httpError(404, `no session ${id}`);
+	if (!reopenable(s)) throw httpError(409, `${id} cannot start again on its conversation: ${canResume(s.agent) ? "work has not learned it yet (it comes with the first prompt's hook)" : `${agentLabel(s.agent)} cannot resume one`}`);
+	const next = resumeAs(id, s.agent, agent);
+	const wsPath = workspacePath(s.workspace_id);
+	if (!wsPath) throw httpError(409, `${id}'s workspace is gone`);
+	if (s.launch_dir && launchDir(s, wsPath) === wsPath) throw httpError(409, `${id} ran in ${s.launch_dir}, which is gone, and its conversation with it: ${START_AGAIN}`);
+	const env = cleanEnv();
+	await tmux([
+		"kill-session",
+		"-t",
+		tmuxName(id)
+	], env).catch(() => {});
+	forgetPanes();
+	clearTmuxStarted(id);
+	clearAgentPhase(id);
+	db.prepare("UPDATE sessions SET agent = ? WHERE id = ?").run(next, id);
+	const session = getSession(id);
+	await ensureTmuxServer();
+	await launchDetached(session, wsPath, env, { resume: s.conversation });
+	if (!await paneAlive(id, env)) {
+		db.prepare("UPDATE sessions SET agent = ? WHERE id = ?").run(s.agent, id);
+		notifySessionsChanged(s.workspace_id);
+		throw httpError(409, `${id}'s ${agentLabel(next)} could not resume its conversation (${s.conversation})${next === s.agent ? "" : `: ${next} may keep its conversations apart from ${s.agent}'s`}, and its pane has closed: \`work session reopen ${id}\` tries again`);
+	}
+	notifySessionsChanged(s.workspace_id);
+	return session;
+}
+/** What a session is, open or closed (`work session list <id>`, `log`):
+* undefined for one work does not know, or no longer keeps. */
+function sessionInfo(id) {
+	const live = getSession(id);
+	const closed = live ? void 0 : closedSession(id);
+	const s = live ?? closed;
+	if (!s) return;
+	return {
+		id: s.id,
+		agent: s.agent,
+		title: s.title,
+		workspace: s.workspace_id,
+		parent: s.parent_id,
+		summary: s.summary,
+		/** How and when it closed; null while open. */
+		closed: closed ? {
+			how: closed.how,
+			at: closed.closed_at
+		} : null,
+		/** It can start again on its conversation (`work session reopen`). */
+		reopenable: reopenable(s)
+	};
+}
+function paneAlive(id, env) {
+	return tmux([
+		"has-session",
+		"-t",
+		tmuxName(id)
+	], env).then(() => true, () => false);
+}
 /** Every session `id` started, and theirs, nearest first. */
 function descendantsOf(id) {
 	return all(`WITH RECURSIVE kids(id, depth) AS (
@@ -17591,7 +17839,7 @@ function notifySessionsChanged(workspaceId) {
 async function emitSessionsChanged(workspaceId) {
 	try {
 		const states = await sessionStates();
-		const { teamsOf } = await import("./_Dbtwc-4J.js");
+		const { teamsOf } = await import("./_hjIYs3Gy.js");
 		publish("sessions.changed", {
 			workspaceId,
 			sessions: listSessions(workspaceId).map((s) => ({
@@ -17613,7 +17861,37 @@ async function killWorkspaceSessions(workspaceId) {
 * that passes one through, typing the rest into the pane as keys. */
 var PASTE_UNSAFE = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\x9f]/g;
 /** Type text into a session's tmux (bracketed paste + Enter), creating it if needed. */
-async function sendToSession(id, raw, size, submit = ["Enter"]) {
+async function sendToSession(...args) {
+	const { sent } = await pasteToSession(...args);
+	await sent;
+}
+/** Each session's send under way. One at a time: a paste landing ahead of
+* the last one's keys joins its prompt, and its own keys then press Enter
+* on whatever that prompt set off. */
+var sendTail = /* @__PURE__ */ new Map();
+/** `sendToSession` for a caller that waits only for the text to be in the
+* pane: `sent` settles once the keys that send it have followed, which
+* for most CLIs waits out the paste being drawn (`pressSubmit`). */
+async function pasteToSession(id, raw, size, submit = ["Enter"], lead) {
+	const last = sendTail.get(id);
+	let free = () => {};
+	const mine = new Promise((resolve) => free = resolve);
+	sendTail.set(id, mine);
+	await last;
+	const end = () => {
+		if (sendTail.get(id) === mine) sendTail.delete(id);
+		free();
+	};
+	try {
+		const { sent } = await pasteNow(id, raw, size, submit, lead);
+		return { sent: sent.finally(end) };
+	} catch (err) {
+		end();
+		throw err;
+	}
+}
+async function pasteNow(id, raw, size, submit, lead) {
+	const typed = lead?.replace(PASTE_UNSAFE, "").replace(/\s*[\r\n]+\s*/g, " ").trim().replace(/;$/, "; ");
 	const text = raw.replace(PASTE_UNSAFE, "");
 	const session = getSession(id);
 	if (!session) throw new Error("unknown session");
@@ -17630,8 +17908,9 @@ async function sendToSession(id, raw, size, submit = ["Enter"]) {
 		await ensureTmuxServer();
 		clearAgentPhase(id);
 		if (promptAsArgv(session.agent)) {
+			const prompt = typed ? `${typed}\n\n${text}` : text;
 			const file = path.join(os.tmpdir(), `work-prompt-${id}-${Math.random().toString(36).slice(2, 10)}`);
-			fs.writeFileSync(file, text, {
+			fs.writeFileSync(file, prompt, {
 				mode: 384,
 				flag: "wx"
 			});
@@ -17639,7 +17918,7 @@ async function sendToSession(id, raw, size, submit = ["Enter"]) {
 				await tmux(newSessionArgs(session, wsPath, "-d", {
 					prompt: {
 						file,
-						text
+						text: prompt
 					},
 					size
 				}), env);
@@ -17648,7 +17927,7 @@ async function sendToSession(id, raw, size, submit = ["Enter"]) {
 				throw err;
 			}
 			markTmuxStarted(id);
-			return;
+			return { sent: Promise.resolve() };
 		}
 		await launchDetached(session, wsPath, env, { size });
 	}
@@ -17663,13 +17942,7 @@ async function sendToSession(id, raw, size, submit = ["Enter"]) {
 		if (asking) throw httpError(409, `${asking}: answer it in the terminal, then send again`);
 	}
 	const buffer = `work-send-${Math.random().toString(36).slice(2, 8)}`;
-	await tmux([
-		"load-buffer",
-		"-b",
-		buffer,
-		"-"
-	], env, { stdin: text });
-	await tmux([
+	const pasted = [
 		"paste-buffer",
 		"-p",
 		"-d",
@@ -17677,9 +17950,42 @@ async function sendToSession(id, raw, size, submit = ["Enter"]) {
 		buffer,
 		"-t",
 		name
-	], env);
-	await waitStill(name, env, PASTE_SETTLE_MS);
+	];
+	const keys = typed ? [
+		"send-keys",
+		"-t",
+		name,
+		"-l",
+		typed
+	] : [];
+	if (text || !typed) await tmux([
+		"load-buffer",
+		"-b",
+		buffer,
+		"-"
+	], env, { stdin: text });
+	const paste = !typed ? pasted : text ? [
+		...keys,
+		";",
+		...pasted
+	] : keys;
+	const behind = submitsBehindPaste(session.agent) && submit.length ? 1 : 0;
+	await tmux(behind ? [
+		...paste,
+		";",
+		"send-keys",
+		"-t",
+		name,
+		submit[0]
+	] : paste, env);
+	return { sent: pressSubmit(name, env, submit, behind) };
+}
+/** The keys that send what was just pasted into `name`, past the
+* `pressed` that went with the paste. */
+async function pressSubmit(name, env, submit, pressed) {
+	if (!pressed) await waitStill(name, env, PASTE_SETTLE_MS);
 	for (const [i, key] of submit.entries()) {
+		if (i < pressed) continue;
 		if (i) await sleep(KEY_GAP_MS);
 		await tmux([
 			"send-keys",
@@ -19247,13 +19553,19 @@ ${repoLines}
   every result since they last wrote, not just the newest, and what is
   still due. A message waits for the turn under way to end,
   which can take hours: a correction or a stop goes with \`--now\` (into
-  that turn, at its next step) or \`--interrupt\` (stops it first). \`work session fanout --agent <id>… --prompt "<task {}>" <item>…\`
+  that turn, at its next step) or \`--interrupt\` (stops it first), as
+  one with \`--no-reply\` does by itself; one already queued goes so with
+  \`send <id> --now\` and no text, never sent twice. \`work session fanout --agent <id>… --prompt "<task {}>" <item>…\`
   starts a group, a few at a time, whose replies come back as one prompt
   (\`work session team\` shows how far they are). \`--topic <name>\` gives each a
   topic branch of its own; send paths, not pasted files. They close once
   answered and done with, as each reply says (\`--keep\`, or
   \`work session keep <id>\` later, keeps one), and a message to a closed
-  Claude or Codex one reopens it on its own conversation. For a quick
+  Claude or Codex one reopens it on its own conversation; one closed
+  otherwise (with its lead, by the user), or stuck on its account's limit,
+  \`work session reopen <id> [--agent <another instance>]\` starts again
+  on it, and \`work session log [<id>]\` shows what went to and from
+  one and how each message went. For a quick
   sweep in your own CLI, its own subagents are cheaper. All of this is
   this workspace's only; an agent in another can be messaged when the user
   asks, and only while it runs (\`work workspaces\` lists them, \`work session list <workspace>\`
@@ -19271,4 +19583,4 @@ ${repoLines}
 `;
 }
 //#endregion
-export { reopenSession as $, setInstance as $n, readBody as $r, notePushActivity as $t, closedSession as A, onFinished as An, setDisabledAgents as Ar, authGithub as At, killWorkspaceSessions as B, turnPhase as Bn, firewallProbe as Br, readBlobAt as Bt, workspaceBranches as C, noteActivity$1 as Cn, changePref as Cr, installServer as Ct, beginCreation as D, noteTyped as Dn, getSetting as Dr, serverList as Dt, agentCaller as E, notePermissionMode as En, enabledAgents as Er, serverById as Et, ensureTmuxServer as F, setExpecting as Fn, ghKnownHosts as Fr, refreshGithub as Ft, markTmuxStarted as G, agentFromCommand as Gn, catalogPin as Gr, setPoints as Gt, listPanes as H, turnSince as Hn, TOOLS as Hr, reviewWaiting as Ht, forgetPanes as I, setScrapedPhase as In, miseInstalls as Ir, removeTool as It, notifySessionsChanged as J, ACCENT_RE as Jn, applyPrefChange as Jr, commentFolder as Jt, newSessionArgs as K, agentLabel as Kn, parseAgentId as Kr, startSnapSweep as Kt, getSession as L, setSessionViewers as Ln, miseVersions as Lr, runStreaming as Lt, creationOf as M, onTurnEnd as Mn, setSetting as Mr, installMise as Mt, descendantsOf as N, sessionWatched as Nn, discoverAgents as Nr, installTool as Nt, cleanEnv as O, noteUserAnswered as On, isKnownAgent as Or, sharing as Ot, disposeSessions as P, setAgentPhase as Pn, doctor as Pr, logoutGithub as Pt, renameSession as Q, normalizeAccent as Qn, httpError as Qr, hotBatchMinMs as Qt, interruptSession as R, settleQuietWorking as Rn, which as Rr, updateTool as Rt, withProgressOp as S, lastTypedAt as Sn, allPrefs as Sr, installKey as St, hookToken as T, noteInterrupt as Tn, disabledAgents as Tr, removeServer as Tt, listPanesWithin as U, agentBadge as Un, agentById as Ur, workspaceDiff as Ut, launchDir as V, turnSettling as Vn, PROJECT_TOOLS as Vr, readFileAt as Vt, listSessions as W, agentFamily as Wn, agentLabel$1 as Wr, workspaceSections as Wt, ownWorkspaceOnly as X, iconSvg as Xn, FRAME_HEADERS as Xr, sectionFor as Xt, onSessionDispose as Y, getInstance as Yn, FRAME_ANCESTORS as Yr, markBranch as Yt, panePids as Z, manifest as Zn, checked as Zr, dismissPr as Zt, retryMaterialize as _, agentPhase as _n, removeHost as _r, stopServers as _t, ensureUntrackedCache as a, db as ai, interruptKeys as an, headOid as ar, tmuxWasStarted as at, sweepTrash as b, hookReportedAt as bn, WORKSPACE_PREFS as br, forgetCustomServer as bt, insertPendingWorkspace as c, ownsBranchOf as ci, steerKeys as cn, repoCatalog as cr, workspaceProcs as ct, progress as d, git as di, readCache as dn, addHost as dr, lspQuery as dt, publish as ei, refreshPrsBatch as en, deleteSubscription as er, reopenable as et, progressSince as f, tmux as fi, writeCache as fn, configuredHosts as fr, lspQueryOf as ft, resumePendingWorkspaces as g, activityOf as gn, normalizeHost as gr, stopAllServers as gt, removeRepo as h, withLock as hi, realInside as hn, isValidHost as hr, runningServers as ht, deleteWorkspace as i, all as ii, AGENTS as in, validSubscription as ir, tmuxName as it, createSession as j, onPhaseChange as jn, setPref as jr, installAgent as jt, clearTmuxStarted as k, notifyEventOn as kn, preferredAgent as kr, whileInstalling as kt, listWorkspaces as l, ensureAllCacheConfig as li, blankRow as ln, repoDefaultBranch as lr, killServers as lt, queueMaterialize as m, swr as mi, inside as mn, forgetToken as mr, lspWarm as mt, barePath as n, subscribe as ni, workspacePrs as nn, saveSubscription as nr, sendToSession as nt, gcBares as o, get as oi, readHookPayload as on, pendingSsoOrgs as or, killWorkspaceProc as ot, pruneLaneBranch as p, config as pi, cleanSummary as pn, ensureGitCredentials as pr, lspUses as pt, noteConversation as q, agentMeta as qn, toolById as qr, diffStamp as qt, createWorkspace as r, subscriberCount as ri, noteActivity as rn, sendPush as rr, sessionStates as rt, getWorkspace as s, workspacePath as si, reportsWorking as sn, repoBranches as sr, portsByWorkspace as st, addRepo as t, publishJson as ti, withoutDismissed as tn, pushPublicKey as tr, retireSession as tt, otherWorkspaceBranches as u, TMUX_SOCKET as ui, credentialStamp as un, DEFAULT_HOST as ur, lspDiagnostics as ut, revParse as v, clearAgentPhase as vn, unreachableRepos as vr, addCustomServer as vt, ensureAllPushHooks as w, noteBackground as wn, deleteSetting as wr, lspEnabled as wt, syncAgentsMd as x, interruptedSinceReport as xn, agentChoices as xr, forgetProbes as xt, setWorkspaceStatus as y, hookPhase as yn, PREF_MAX as yr, allServers as yt, killSession as z, summaryOf as zn, bornOut as zr, fileChanges as zt };
+export { renameSession as $, agentMeta as $n, toolById as $r, sectionFor as $t, closedSession as A, notePermissionMode as An, deleteSetting as Ar, serverList as At, killWorkspaceSessions as B, setAgentPhase as Bn, doctor as Br, runStreaming as Bt, workspaceBranches as C, hookPhase as Cn, removeHost as Cr, forgetCustomServer as Ct, beginCreation as D, noteActivity$1 as Dn, agentChoices as Dr, lspEnabled as Dt, agentCaller as E, lastTypedAt as En, WORKSPACE_PREFS as Er, installServer as Et, ensureTmuxServer as F, onFinished as Fn, preferredAgent as Fr, installMise as Ft, markTmuxStarted as G, summaryOf as Gn, bornOut as Gr, reviewWaiting as Gt, listPanes as H, setScrapedPhase as Hn, miseInstalls as Hr, fileChanges as Ht, forgetPanes as I, onPhaseChange as In, setDisabledAgents as Ir, installTool as It, notifySessionsChanged as J, turnSince as Jn, TOOLS as Jr, setPoints as Jt, newSessionArgs as K, turnPhase as Kn, firewallProbe as Kr, workspaceDiff as Kt, getSession as L, onTurnEnd as Ln, setPref as Lr, logoutGithub as Lt, creationOf as M, noteTyped as Mn, enabledAgents as Mr, whileInstalling as Mt, descendantsOf as N, noteUserAnswered as Nn, getSetting as Nr, authGithub as Nt, cleanEnv as O, noteBackground as On, allPrefs as Or, removeServer as Ot, disposeSessions as P, notifyEventOn as Pn, isKnownAgent as Pr, installAgent as Pt, pasteToSession as Q, agentLabel as Qn, parseAgentId as Qr, markBranch as Qt, interruptSession as R, onTurnFailed as Rn, setSetting as Rr, refreshGithub as Rt, withProgressOp as S, clearAgentPhase as Sn, normalizeHost as Sr, allServers as St, hookToken as T, interruptedSinceReport as Tn, PREF_MAX as Tr, installKey as Tt, listPanesWithin as U, setSessionViewers as Un, miseVersions as Ur, readBlobAt as Ut, launchDir as V, setExpecting as Vn, ghKnownHosts as Vr, updateTool as Vt, listSessions as W, settleQuietWorking as Wn, which as Wr, readFileAt as Wt, ownWorkspaceOnly as X, agentFamily as Xn, agentLabel$1 as Xr, diffStamp as Xt, onSessionDispose as Y, agentBadge as Yn, agentById as Yr, startSnapSweep as Yt, panePids as Z, agentFromCommand as Zn, catalogPin as Zr, commentFolder as Zt, retryMaterialize as _, git as _i, cleanSummary as _n, addHost as _r, lspWarm as _t, ensureUntrackedCache as a, readBody as ai, workspacePrs as an, setInstance as ar, sessionInfo as at, sweepTrash as b, swr as bi, activityOf as bn, forgetToken as br, stopServers as bt, insertPendingWorkspace as c, subscribe as ci, interruptKeys as cn, saveSubscription as cr, tmuxWasStarted as ct, progress as d, db as di, reportsWorking as dn, headOid as dr, workspaceProcs as dt, applyPrefChange as ei, dismissPr as en, ACCENT_RE as er, reopenSession as et, progressSince as f, get as fi, steerKeys as fn, pendingSsoOrgs as fr, killServers as ft, resumePendingWorkspaces as g, TMUX_SOCKET as gi, writeCache as gn, DEFAULT_HOST as gr, lspUses as gt, removeRepo as h, ensureAllCacheConfig as hi, readCache as hn, repoDefaultBranch as hr, lspQueryOf as ht, deleteWorkspace as i, httpError as ii, withoutDismissed as in, normalizeAccent as ir, sendToSession as it, createSession as j, noteTurnFailed as jn, disabledAgents as jr, sharing as jt, clearTmuxStarted as k, noteInterrupt as kn, changePref as kr, serverById as kt, listWorkspaces as l, subscriberCount as li, quotesPastes as ln, sendPush as lr, killWorkspaceProc as lt, queueMaterialize as m, ownsBranchOf as mi, credentialStamp as mn, repoCatalog as mr, lspQuery as mt, barePath as n, FRAME_HEADERS as ni, notePushActivity as nn, iconSvg as nr, restartSession as nt, gcBares as o, publish as oi, noteActivity as on, deleteSubscription as or, sessionStates as ot, pruneLaneBranch as p, workspacePath as pi, blankRow as pn, repoBranches as pr, lspDiagnostics as pt, noteConversation as q, turnSettling as qn, PROJECT_TOOLS as qr, workspaceSections as qt, createWorkspace as r, checked as ri, refreshPrsBatch as rn, manifest as rr, retireSession as rt, getWorkspace as s, publishJson as si, AGENTS as sn, pushPublicKey as sr, tmuxName as st, addRepo as t, FRAME_ANCESTORS as ti, hotBatchMinMs as tn, getInstance as tr, reopenable as tt, otherWorkspaceBranches as u, all as ui, readHookPayload as un, validSubscription as ur, portsByWorkspace as ut, revParse as v, tmux as vi, inside as vn, configuredHosts as vr, runningServers as vt, ensureAllPushHooks as w, hookReportedAt as wn, unreachableRepos as wr, forgetProbes as wt, syncAgentsMd as x, withLock as xi, agentPhase as xn, isValidHost as xr, addCustomServer as xt, setWorkspaceStatus as y, config as yi, realInside as yn, ensureGitCredentials as yr, stopAllServers as yt, killSession as z, sessionWatched as zn, discoverAgents as zr, removeTool as zt };