@dylanpiercey/work 0.2.54 → 0.2.55

package/dist/{_CIYlzn8G.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);
       `);
 		}
 	}
@@ -9348,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);
@@ -9559,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("./_B4B_SliZ.js").then((m) => m.notifySessionsChanged(workspaceId));
+		import("./_CVNGN2QO.js").then((m) => m.notifySessionsChanged(workspaceId));
 		return;
 	}
 	publish("sessions.changed");
@@ -10290,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);
@@ -10308,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
@@ -10390,6 +10465,7 @@ var claude = {
 	resumeFlags: (id) => ["--resume", id],
 	steerKeys: ["Enter"],
 	submitsBehindPaste: true,
+	quotesPastes: true,
 	interruptKeys: ["Escape"],
 	envPrefixes: ["CLAUDE", "AI_AGENT"],
 	startupQuestions: [{
@@ -11742,6 +11818,10 @@ function promptAsArgv(id) {
 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) {
@@ -17511,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 (
@@ -17679,7 +17839,7 @@ function notifySessionsChanged(workspaceId) {
 async function emitSessionsChanged(workspaceId) {
 	try {
 		const states = await sessionStates();
-		const { teamsOf } = await import("./_D-u1Rg6e.js");
+		const { teamsOf } = await import("./_hjIYs3Gy.js");
 		publish("sessions.changed", {
 			workspaceId,
 			sessions: listSessions(workspaceId).map((s) => ({
@@ -17712,7 +17872,7 @@ 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"]) {
+async function pasteToSession(id, raw, size, submit = ["Enter"], lead) {
 	const last = sendTail.get(id);
 	let free = () => {};
 	const mine = new Promise((resolve) => free = resolve);
@@ -17723,14 +17883,15 @@ async function pasteToSession(id, raw, size, submit = ["Enter"]) {
 		free();
 	};
 	try {
-		const { sent } = await pasteNow(id, raw, size, submit);
+		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) {
+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");
@@ -17747,8 +17908,9 @@ async function pasteNow(id, raw, size, submit) {
 		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"
 			});
@@ -17756,7 +17918,7 @@ async function pasteNow(id, raw, size, submit) {
 				await tmux(newSessionArgs(session, wsPath, "-d", {
 					prompt: {
 						file,
-						text
+						text: prompt
 					},
 					size
 				}), env);
@@ -17780,13 +17942,7 @@ async function pasteNow(id, raw, size, submit) {
 		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 });
-	const paste = [
+	const pasted = [
 		"paste-buffer",
 		"-p",
 		"-d",
@@ -17795,6 +17951,24 @@ async function pasteNow(id, raw, size, submit) {
 		"-t",
 		name
 	];
+	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,
@@ -19379,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>\`
@@ -19403,4 +19583,4 @@ ${repoLines}
 `;
 }
 //#endregion
-export { renameSession as $, normalizeAccent as $n, httpError as $r, hotBatchMinMs as $t, closedSession as A, notifyEventOn as An, preferredAgent as Ar, whileInstalling as At, killWorkspaceSessions as B, summaryOf as Bn, bornOut as Br, fileChanges as Bt, workspaceBranches as C, lastTypedAt as Cn, allPrefs as Cr, installKey as Ct, beginCreation as D, notePermissionMode as Dn, enabledAgents as Dr, serverById as Dt, agentCaller as E, noteInterrupt as En, disabledAgents as Er, removeServer as Et, ensureTmuxServer as F, setAgentPhase as Fn, doctor as Fr, logoutGithub as Ft, markTmuxStarted as G, agentFamily as Gn, agentLabel$1 as Gr, workspaceSections as Gt, listPanes as H, turnSettling as Hn, PROJECT_TOOLS as Hr, readFileAt as Ht, forgetPanes as I, setExpecting as In, ghKnownHosts as Ir, refreshGithub as It, notifySessionsChanged as J, agentMeta as Jn, toolById as Jr, diffStamp as Jt, newSessionArgs as K, agentFromCommand as Kn, catalogPin as Kr, setPoints as Kt, getSession as L, setScrapedPhase as Ln, miseInstalls as Lr, removeTool as Lt, creationOf as M, onPhaseChange as Mn, setPref as Mr, installAgent as Mt, descendantsOf as N, onTurnEnd as Nn, setSetting as Nr, installMise as Nt, cleanEnv as O, noteTyped as On, getSetting as Or, serverList as Ot, disposeSessions as P, sessionWatched as Pn, discoverAgents as Pr, installTool as Pt, pasteToSession as Q, manifest as Qn, checked as Qr, dismissPr as Qt, interruptSession as R, setSessionViewers as Rn, miseVersions as Rr, runStreaming as Rt, withProgressOp as S, interruptedSinceReport as Sn, agentChoices as Sr, forgetProbes as St, hookToken as T, noteBackground as Tn, deleteSetting as Tr, lspEnabled as Tt, listPanesWithin as U, turnSince as Un, TOOLS as Ur, reviewWaiting as Ut, launchDir as V, turnPhase as Vn, firewallProbe as Vr, readBlobAt as Vt, listSessions as W, agentBadge as Wn, agentById as Wr, workspaceDiff as Wt, ownWorkspaceOnly as X, getInstance as Xn, FRAME_ANCESTORS as Xr, markBranch as Xt, onSessionDispose as Y, ACCENT_RE as Yn, applyPrefChange as Yr, commentFolder as Yt, panePids as Z, iconSvg as Zn, FRAME_HEADERS as Zr, sectionFor as Zt, retryMaterialize as _, activityOf as _n, normalizeHost as _r, stopAllServers as _t, ensureUntrackedCache as a, all as ai, AGENTS as an, validSubscription as ar, tmuxName as at, sweepTrash as b, hookPhase as bn, PREF_MAX as br, allServers as bt, insertPendingWorkspace as c, workspacePath as ci, reportsWorking as cn, repoBranches as cr, portsByWorkspace as ct, progress as d, TMUX_SOCKET as di, credentialStamp as dn, DEFAULT_HOST as dr, lspDiagnostics as dt, readBody as ei, notePushActivity as en, setInstance as er, reopenSession as et, progressSince as f, git as fi, readCache as fn, addHost as fr, lspQuery as ft, resumePendingWorkspaces as g, withLock as gi, realInside as gn, isValidHost as gr, runningServers as gt, removeRepo as h, swr as hi, inside as hn, forgetToken as hr, lspWarm as ht, deleteWorkspace as i, subscriberCount as ii, noteActivity as in, sendPush as ir, sessionStates as it, createSession as j, onFinished as jn, setDisabledAgents as jr, authGithub as jt, clearTmuxStarted as k, noteUserAnswered as kn, isKnownAgent as kr, sharing as kt, listWorkspaces as l, ownsBranchOf as li, steerKeys as ln, repoCatalog as lr, workspaceProcs as lt, queueMaterialize as m, config as mi, cleanSummary as mn, ensureGitCredentials as mr, lspUses as mt, barePath as n, publishJson as ni, withoutDismissed as nn, pushPublicKey as nr, retireSession as nt, gcBares as o, db as oi, interruptKeys as on, headOid as or, tmuxWasStarted as ot, pruneLaneBranch as p, tmux as pi, writeCache as pn, configuredHosts as pr, lspQueryOf as pt, noteConversation as q, agentLabel as qn, parseAgentId as qr, startSnapSweep as qt, createWorkspace as r, subscribe as ri, workspacePrs as rn, saveSubscription as rr, sendToSession as rt, getWorkspace as s, get as si, readHookPayload as sn, pendingSsoOrgs as sr, killWorkspaceProc as st, addRepo as t, publish as ti, refreshPrsBatch as tn, deleteSubscription as tr, reopenable as tt, otherWorkspaceBranches as u, ensureAllCacheConfig as ui, blankRow as un, repoDefaultBranch as ur, killServers as ut, revParse as v, agentPhase as vn, removeHost as vr, stopServers as vt, ensureAllPushHooks as w, noteActivity$1 as wn, changePref as wr, installServer as wt, syncAgentsMd as x, hookReportedAt as xn, WORKSPACE_PREFS as xr, forgetCustomServer as xt, setWorkspaceStatus as y, clearAgentPhase as yn, unreachableRepos as yr, addCustomServer as yt, killSession as z, settleQuietWorking as zn, which as zr, updateTool 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 };

package/dist/_hjIYs3Gy.js

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