@dylanpiercey/work 0.2.60 → 0.2.62

package/bin/cli/session.mjs

@@ -263,11 +263,36 @@ function printGroup(ctx, g) {
     );
 }
 
+/** What `work session list <id>` knows of a session; dies on none. */
+async function infoOf(ctx, id) {
+  const s = await ctx.api.get(
+    `/api/sessions/${encodeURIComponent(id)}?missing=null`,
+  );
+  if (!s) ctx.die(`no session ${id} (see: work session list)`);
+  return s;
+}
+
+/** Whether this command runs for an agent, not the user: from an agent's
+ * own pane, not a shell's or a terminal outside work. */
+async function callerIsAgent(ctx) {
+  const me = process.env.WORK_SESSION_ID;
+  if (!me) return false;
+  const s = await ctx.api.get(
+    `/api/sessions/${encodeURIComponent(me)}?missing=null`,
+  );
+  return !!s && s.agent !== "shell";
+}
+
+/** Why an agent wants --yes for a change to the user's own session. */
+function userOwn(id, what, lead) {
+  return `${id} is the user's own session (no agent started it)${lead ? `: under ${lead} its turns no longer notify them, its last message is written for ${lead}, it folds into ${lead}'s team in the list, and closing ${lead} closes it` : `, to be ${what}`}. Pass --yes only if the user asked for this`;
+}
+
 export const commands = [
   {
     name: "session",
     summary:
-      "this session and the workspace's others: new, fanout, send, wait, hold, keep, reopen, log, team, kill",
+      "this session and the workspace's others: new, fanout, send, unsend, wait, hold, forget, keep, adopt, release, retire, reopen, log, team, kill",
     help: `work session [--json]
   This session (WORK_SESSION_ID): its id, agent, name, state, and the
   workspace it is in (id, name, path) — what a link names (/w/<id>/…).
@@ -320,7 +345,8 @@ work session retry <member>
   Rerun a closed member in a fresh session: its group waits for it again.
 work session skip <member>
   Stop a member: a queued one never starts, a running one's session
-  closes; either way its group no longer waits on it.
+  closes, ending its turn and whatever its pane runs; either way its group
+  no longer waits on it. \`forget\` stops waiting on one that works on.
 work session send <id> "<text>"|- [--no-reply] [--now|--interrupt]
   Message an agent session: typed in, headed with who it is from, once
   it is at its prompt — never into a question it asks or a draft someone
@@ -353,7 +379,10 @@ work session send <id> "<text>"|- [--no-reply] [--now|--interrupt]
   another workspace (\`work session list <workspace>\`) can be messaged
   when the user asks, and only while it runs; everything else here an
   agent does in its own workspace only.
-work session reopen <id> [--agent <id>]
+work session unsend <id>
+  Take back what this session queued for <id> that is not typed in yet:
+  a message that went in stays in its turn (send a correction instead).
+work session reopen <id> [--agent <id>] [--now]
   Start a session again on its own conversation, where its CLI can resume
   one (Claude, Codex): one closed — by its lead's close, the user's, or
   for being done — back under the session that started it, or under this
@@ -361,7 +390,10 @@ work session reopen <id> [--agent <id>]
   starts it as another instance of the same CLI (claude2 for claude):
   one stuck because its account hit a limit goes on as another account's,
   where the two share their conversations. What is queued for it and what
-  it owes you stay: send it a message to carry it on.
+  it owes you stay: send it a message to carry it on. A restart ends the
+  turn under way and what its pane runs (a background job, a dev server),
+  so a running one mid-turn or with jobs is refused, saying what it is
+  on, unless --now.
 work session wait [<id>|<group>...] [--any] [--timeout <seconds>]
   Wait for the replies owed to this session (by those sessions or groups,
   else by any), printing each as it comes; a reply printed here is not
@@ -376,18 +408,48 @@ work session hold "<what you wait on>"
   nothing more until they write to you); you are not closed for being
   done meanwhile; and the last message of the turn the job's end wakes
   you into is the reply (hold again there to wait on more).
+work session forget <id|member>…
+  Stop waiting on what a session owes this one, without stopping it: its
+  turn's end answers nobody, and what is still queued from you goes in
+  wanting no reply (a reply it sent already still comes). A fan-out
+  member's group no longer waits on it: a queued one never starts, a
+  running one works on, under you. Nothing is told to it.
 work session keep <id>
   Keep a session this one started open for follow-ups, as \`new --keep\`
   would have: it is never closed for being done.
+work session adopt <id>… [--lead <id>] [--from <lead>] [--close-done] [--yes]
+  Put a running session under this one (or --lead), as if this one had
+  started it, with nothing restarted: the list nests it, \`list <lead>\`,
+  \`kill <lead>\` and \`reopen\` treat it as the lead's, its replies are
+  its turns' ends, its turns no longer notify the user (the lead's news),
+  and its permission mode stays its own. What is queued for it or owed
+  keeps how it is answered. Kept open (never closed for being done)
+  unless --close-done, which closes it once it has answered from now on.
+  One under another lead moves only with --from naming it. A session the
+  user started is theirs: an agent passes --yes only when the user asked.
+work session release <id>…
+  Stand a session on its own again, as \`kill --keep-children\` leaves the
+  ones it started: nothing restarts, and what it owes stays owed.
+work session retire <id>… [--yes]
+  Close a session once closing it loses nothing: no turn under way,
+  nothing queued for it, owed by or to it, no session it leads still open,
+  not on the user's screen, and nothing left running in its pane. Now if
+  that is now, else when the last of those ends; typing into it first
+  takes this back. Closed so, a message reopens it on its conversation.
+  This one retired closes once its turn has ended. A session the user
+  started is theirs: an agent passes --yes only when the user asked.
 work session kill <id> [--keep-children] --yes
   Close a session and the process in it, and the sessions it started
-  with theirs, unless --keep-children (they then stand on their own).
-  Whoever waits on a reply from one is told. Each that can resume its
+  with theirs, unless --keep-children (they then stand on their own): the
+  turn under way, what its pane runs and what is queued for it end, and
+  whoever waits on a reply from one is told. Each that can resume its
   conversation can be started again for a week: \`work session reopen\`.
+  \`retire\` closes one without losing anything.
 work session kill --done
   Close now the sessions this one started that are done with (answered,
-  idle, not the user's): fan-out results stay in \`work session team\`,
-  and a message to one reopens it, as \`send\` says.`,
+  idle, not the user's, nothing left running in its pane): fan-out
+  results stay in \`work session team\`, and a message to one reopens it,
+  as \`send\` says.`,
     async run(ctx) {
       const [verb, ...rest] = ctx.parse([
         "--agent",
@@ -401,6 +463,8 @@ work session kill --done
         "--count",
         "--parallel",
         "--limit",
+        "--lead",
+        "--from",
       ]);
       switch (verb) {
         case undefined: {
@@ -712,10 +776,12 @@ work session kill --done
         }
         case "reopen": {
           const [id] = rest;
-          if (!id) ctx.die("usage: work session reopen <id> [--agent <id>]");
+          if (!id)
+            ctx.die("usage: work session reopen <id> [--agent <id>] [--now]");
           const agent = ctx.flag("--agent");
           const r = await ctx.api.post(`/api/sessions/${id}/reopen${by()}`, {
             ...(agent ? { agent } : {}),
+            ...(ctx.has("--now") ? { now: true } : {}),
           });
           return ctx.out(r, (r) => {
             console.log(
@@ -726,6 +792,122 @@ work session kill --done
             );
           });
         }
+        case "unsend": {
+          const me = sessionId(ctx);
+          const [id] = rest;
+          if (!id) ctx.die("usage: work session unsend <id>");
+          const { withdrawn } = await ctx.api.post(
+            `/api/sessions/${encodeURIComponent(id)}/unsend?by=${encodeURIComponent(me)}`,
+          );
+          return ctx.out({ id, withdrawn }, () =>
+            console.log(
+              `took back ${withdrawn === 1 ? "your message" : `your ${withdrawn} messages`} queued for ${id}`,
+            ),
+          );
+        }
+        case "forget": {
+          const me = sessionId(ctx);
+          if (!rest.length) ctx.die("usage: work session forget <id|member>…");
+          const out = [];
+          for (const id of rest)
+            out.push({
+              id,
+              ...(await ctx.api.post(
+                `/api/sessions/${encodeURIComponent(id)}/forget?by=${encodeURIComponent(me)}`,
+              )),
+            });
+          return ctx.out(out, (rows) => {
+            for (const r of rows)
+              console.log(
+                r.member
+                  ? `forgot member ${r.member}: its group no longer waits on it${r.session ? `, and ${r.session} works on, under you` : ""}`
+                  : `forgot what ${r.id} owes you: it works on, and its turn's end answers nobody`,
+              );
+          });
+        }
+        case "adopt": {
+          if (!rest.length)
+            ctx.die(
+              "usage: work session adopt <id>… [--lead <id>] [--from <lead>] [--close-done] [--yes]",
+            );
+          const lead = ctx.flag("--lead") || process.env.WORK_SESSION_ID;
+          if (!lead)
+            ctx.die("not in a work session: pass --lead <id> to adopt under");
+          const fromAgent = await callerIsAgent(ctx);
+          for (const id of rest) {
+            const s = await infoOf(ctx, id);
+            if (s.closed)
+              ctx.die(
+                `${id} has closed: \`work session reopen ${id}\` from ${lead} starts it again under it`,
+              );
+            if (fromAgent && !s.parent && !ctx.yes)
+              ctx.die(userOwn(id, `under ${lead}`, lead));
+          }
+          const out = [];
+          for (const id of rest)
+            out.push(
+              await ctx.api.post(
+                `/api/sessions/${encodeURIComponent(id)}/parent${by()}`,
+                {
+                  parent: lead,
+                  ...(ctx.flag("--from") ? { from: ctx.flag("--from") } : {}),
+                  ...(ctx.has("--close-done") ? { closeDone: true } : {}),
+                },
+              ),
+            );
+          return ctx.out(out, (rows) => {
+            for (const r of rows)
+              console.log(
+                `${r.id} is under ${r.parent} now, ${r.kept ? "kept open (`work session retire` closes it once nothing is lost)" : "closed once it has answered and is done with"}`,
+              );
+            console.log(
+              `Its turns' ends are replies to what ${lead} asks, and notify nobody; \`work session release\` stands it on its own again.`,
+            );
+          });
+        }
+        case "release": {
+          if (!rest.length) ctx.die("usage: work session release <id>…");
+          const out = [];
+          for (const id of rest)
+            out.push(
+              await ctx.api.post(
+                `/api/sessions/${encodeURIComponent(id)}/parent${by()}`,
+                { parent: null },
+              ),
+            );
+          return ctx.out(out, (rows) => {
+            for (const r of rows)
+              console.log(
+                `${r.id} stands on its own now, in the permission mode it ran in`,
+              );
+          });
+        }
+        case "retire": {
+          if (!rest.length) ctx.die("usage: work session retire <id>… [--yes]");
+          const me = process.env.WORK_SESSION_ID;
+          const fromAgent = await callerIsAgent(ctx);
+          for (const id of rest) {
+            const s = await infoOf(ctx, id);
+            if (fromAgent && !s.parent && id !== me && !ctx.yes)
+              ctx.die(userOwn(id, "closed once it is idle"));
+          }
+          const out = [];
+          for (const id of rest)
+            out.push({
+              id,
+              ...(await ctx.api.post(
+                `/api/sessions/${encodeURIComponent(id)}/retire${by()}`,
+              )),
+            });
+          return ctx.out(out, (rows) => {
+            for (const r of rows)
+              console.log(
+                r.closed
+                  ? `closed ${r.id}, which had nothing left to lose: ${r.reopens ? "a message reopens it on its conversation" : "its conversation went with it (its CLI cannot resume one, or work never learned it)"}`
+                  : `${r.id} closes once nothing is lost by it; for now ${r.waits.join(", and ")}. Typing into it takes this back`,
+              );
+          });
+        }
         case "keep": {
           const [id] = rest;
           if (!id) ctx.die("usage: work session keep <id>");
@@ -737,16 +919,20 @@ work session kill --done
         case "kill": {
           if (ctx.has("--done")) {
             const me = sessionId(ctx);
-            const { closed } = await ctx.api.post(
+            const { closed, left = [] } = await ctx.api.post(
               `/api/sessions/${me}/close-done${by()}`,
             );
-            return ctx.out({ closed }, () =>
+            return ctx.out({ closed, left }, () => {
               console.log(
                 closed
                   ? `closed ${closed} finished ${closed === 1 ? "session" : "sessions"}`
-                  : "none of the sessions this one started is done with",
-              ),
-            );
+                  : left.length
+                    ? "closed none: closing would lose something of each"
+                    : "none of the sessions this one started is done with",
+              );
+              for (const l of left)
+                console.log(`  left ${l.id} open: ${l.why.join(", and ")}`);
+            });
           }
           const [id] = rest;
           if (!id)

package/dist/{_xM2b0RL4.js → _BL9uMFqY.js}

@@ -819,6 +819,16 @@ var STEPS = [
         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);
+      `);
+		}
+	},
+	{
+		version: 15,
+		name: "retiring sessions, typing kept",
+		up(db) {
+			db.exec(`
+        ALTER TABLE sessions ADD COLUMN retire_at TEXT;
+        ALTER TABLE sessions ADD COLUMN typed_at INTEGER;
       `);
 		}
 	}
@@ -9479,8 +9489,12 @@ function activityOf(sessionId) {
 }
 /** Someone typed into the session's pane from a page. */
 function noteTyped(sessionId) {
-	typedAt.set(sessionId, Date.now());
+	const now = Date.now();
+	const last = typedAt.get(sessionId) ?? 0;
+	typedAt.set(sessionId, now);
+	if (now - last >= TYPED_KEEP_MS) db.prepare("UPDATE sessions SET typed_at = ? WHERE id = ?").run(now, sessionId);
 }
+var TYPED_KEEP_MS = 1e3;
 /** When someone last typed into the session's pane (0: not this run). */
 function lastTypedAt(sessionId) {
 	return typedAt.get(sessionId) ?? 0;
@@ -9644,7 +9658,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("./_BA6kJ94f.js").then((m) => m.notifySessionsChanged(workspaceId));
+		import("./_BOUuiLtz.js").then((m) => m.notifySessionsChanged(workspaceId));
 		return;
 	}
 	publish("sessions.changed");
@@ -17378,6 +17392,61 @@ async function foregroundRun(panePid, command) {
 	if (!argv?.length) return false;
 	return !!await headlessRun(job, argv[0].split("/").pop() || argv[0], argv.slice(1), table?.get(job)?.tty);
 }
+/** Shells an agent CLI runs its commands in: Claude's Bash tool, Codex's
+* exec. A CLI's other children (stdio MCP servers, language servers) live
+* as long as it does and are none of its jobs. */
+var SHELLS = /* @__PURE__ */ new Set([
+	"bash",
+	"sh",
+	"zsh",
+	"fish",
+	"dash",
+	"ksh"
+]);
+var baseName = (arg) => (arg.split("/").pop() || arg).replace(/^-/, "");
+/** What a CLI at `panePid` still runs in shells of its own — a background
+* job, a dev server, a test run left going — each named by what its
+* shell runs (`pnpm test`), else the shell. Closing or restarting the CLI
+* ends them all with its tmux session, so a close that loses nothing
+* waits for none (server/team `closeBlockers`). */
+async function shellJobs(panePid) {
+	if (darwin) {
+		const table = await processArgs();
+		const kids = (pid) => [...table].filter(([, row]) => row.ppid === pid);
+		return kids(panePid).filter(([, row]) => SHELLS.has(baseName(row.argv[0] ?? ""))).map(([pid, row]) => jobName(kids(pid)[0]?.[1].argv ?? row.argv));
+	}
+	const jobs = [];
+	for (const pid of await childPids(panePid)) {
+		const stat = await procStat(pid);
+		if (!stat.length || stat[0] === "Z") continue;
+		const argv = await procArgs(pid);
+		if (!SHELLS.has(baseName(argv[0] ?? ""))) continue;
+		const [first] = await childPids(pid);
+		jobs.push(jobName(first ? await procArgs(first) : argv));
+	}
+	return jobs;
+}
+/** A job as a line: its command and arguments, paths by their names. */
+function jobName(argv) {
+	const line = argv.map((arg) => arg.startsWith("/") ? baseName(arg) : arg).join(" ");
+	return line.length > 60 ? `${line.slice(0, 59)}…` : line;
+}
+/** A process's children on Linux, every thread's (a Node CLI forks from
+* its worker threads too). */
+async function childPids(pid) {
+	let tasks;
+	try {
+		tasks = await fs$1.readdir(`/proc/${pid}/task`);
+	} catch {
+		return [];
+	}
+	const kids = /* @__PURE__ */ new Set();
+	for (const task of tasks) try {
+		const list = await fs$1.readFile(`/proc/${pid}/task/${task}/children`, "utf8");
+		for (const kid of list.split(" ")) if (kid.trim()) kids.add(Number(kid));
+	} catch {}
+	return [...kids];
+}
 /** Whether a process reads a terminal: its stdin on Linux; on macOS,
 * where a look at one pid's descriptors costs a spawn, whether it has a
 * controlling terminal at all (`ps`'s `??`). Unknown counts as one. */
@@ -17789,6 +17858,10 @@ function sessionInfo(id) {
 		workspace: s.workspace_id,
 		parent: s.parent_id,
 		summary: s.summary,
+		/** Never closed for being done (`work session keep`). */
+		kept: !!live?.keep,
+		/** Since when it is to close once nothing is lost by it (`retire`). */
+		retiring: live?.retire_at ?? null,
 		/** How and when it closed; null while open. */
 		closed: closed ? {
 			how: closed.how,
@@ -17805,6 +17878,37 @@ function paneAlive(id, env) {
 		tmuxName(id)
 	], env).then(() => true, () => false);
 }
+/** What the session's CLI still runs in shells of its own (procs
+* `shellJobs`): its tmux session's close or a restart ends them. */
+async function paneJobs(id) {
+	const pane = (await listPanes())?.find((p) => p.id === id);
+	return pane ? shellJobs(pane.pid) : [];
+}
+/** Put a running session under `parent` (`work session adopt`), or on its
+* own with null (`release`), as `new` would have started it: nothing
+* restarts, and what is queued for it or owed keeps how it is answered
+* (a row's `by_send`). Adopted, it is kept from closing for being done
+* unless `closeDone`, which counts only answers to come: it may have
+* answered someone long ago. Moving one from another lead takes `from`
+* naming that lead. */
+function moveSession(id, parent, opts = {}) {
+	const s = getSession(id);
+	if (!s) throw httpError(404, `no session ${id}`);
+	if (parent === null) {
+		if (s.parent_id) db.prepare("UPDATE sessions SET parent_id = NULL WHERE id = ?").run(id);
+	} else {
+		const lead = getSession(parent);
+		if (!lead) throw httpError(404, `no session ${parent}`);
+		if (lead.workspace_id !== s.workspace_id) throw httpError(409, `${parent} is in another workspace than ${id}`);
+		if (lead.agent === "shell") throw httpError(409, `${parent} is a shell: only an agent leads`);
+		if (parent === id) throw httpError(409, `${id} cannot be under itself`);
+		if (descendantsOf(id).includes(parent)) throw httpError(409, `${parent} is under ${id} already: ${id} cannot also be under it (\`work session release ${parent}\` first)`);
+		if (s.parent_id && s.parent_id !== parent && opts.from !== s.parent_id) throw httpError(409, `${id} is under ${s.parent_id}: pass --from ${s.parent_id} to move it`);
+		db.prepare(`UPDATE sessions SET parent_id = ?, keep = ?${opts.closeDone ? ", answered_at = NULL" : ""} WHERE id = ?`).run(parent, opts.closeDone ? 0 : 1, id);
+	}
+	notifySessionsChanged(s.workspace_id);
+	return getSession(id);
+}
 /** Every session `id` started, and theirs, nearest first. */
 function descendantsOf(id) {
 	return all(`WITH RECURSIVE kids(id, depth) AS (
@@ -17900,7 +18004,7 @@ function notifySessionsChanged(workspaceId) {
 async function emitSessionsChanged(workspaceId) {
 	try {
 		const states = await sessionStates();
-		const { teamsOf } = await import("./_T5K2qs5u.js");
+		const { teamsOf } = await import("./_C-c452mk.js");
 		publish("sessions.changed", {
 			workspaceId,
 			sessions: listSessions(workspaceId).map((s) => ({
@@ -19627,7 +19731,12 @@ ${repoLines}
   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
+  one and how each message went. \`kill\` and \`skip\` end the turn under
+  way and what its pane runs; to lose nothing, \`forget <id>\` stops
+  waiting on a reply, \`unsend <id>\` takes back a message not yet typed
+  in, \`retire <id>\` closes one once it is idle, and \`adopt <id>\` /
+  \`release <id>\` move one under you or off (the user's own only when
+  they ask, with \`--yes\`). 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>\`
@@ -19645,4 +19754,4 @@ ${repoLines}
 `;
 }
 //#endregion
-export { renameSession as $, agentFromCommand as $n, catalogPin as $r, commentFolder as $t, closedSession as A, noteBackground as An, allPrefs as Ar, serverList as At, killWorkspaceSessions as B, onTurnFailed as Bn, setSetting as Br, runStreaming as Bt, workspaceBranches as C, withLock as Ci, agentPhase as Cn, isValidHost as Cr, forgetCustomServer as Ct, beginCreation as D, interruptedSinceReport as Dn, PREF_MAX as Dr, lspEnabled as Dt, agentCaller as E, hookReportedAt as En, unreachableRepos as Er, installServer as Et, ensureTmuxServer as F, noteUserAnswered as Fn, getSetting as Fr, installMise as Ft, markTmuxStarted as G, setSessionViewers as Gn, miseVersions as Gr, readFileAt as Gt, listPanes as H, setAgentPhase as Hn, doctor as Hr, fileChanges as Ht, forgetPanes as I, notifyEventOn as In, isKnownAgent as Ir, installTool as It, notifySessionsChanged as J, turnPhase as Jn, firewallProbe as Jr, workspaceDiff as Jt, newSessionArgs as K, settleQuietWorking as Kn, which as Kr, reviewWaiting as Kt, getSession as L, onFinished as Ln, preferredAgent as Lr, logoutGithub as Lt, creationOf as M, notePermissionMode as Mn, deleteSetting as Mr, whileInstalling as Mt, descendantsOf as N, noteTurnFailed as Nn, disabledAgents as Nr, authGithub as Nt, cleanEnv as O, lastTypedAt as On, WORKSPACE_PREFS as Or, removeServer as Ot, disposeSessions as P, noteTyped as Pn, enabledAgents as Pr, installAgent as Pt, pasteToSession as Q, agentFamily as Qn, agentLabel$1 as Qr, diffStamp as Qt, interruptSession as R, onPhaseChange as Rn, setDisabledAgents as Rr, refreshGithub as Rt, withProgressOp as S, swr as Si, activityOf as Sn, forgetToken as Sr, allServers as St, hookToken as T, hookPhase as Tn, removeHost as Tr, installKey as Tt, listPanesWithin as U, setExpecting as Un, ghKnownHosts as Ur, patchIn as Ut, launchDir as V, sessionWatched as Vn, discoverAgents as Vr, updateTool as Vt, listSessions as W, setScrapedPhase as Wn, miseInstalls as Wr, readBlobAt as Wt, ownWorkspaceOnly as X, turnSince as Xn, TOOLS as Xr, setPoints as Xt, onSessionDispose as Y, turnSettling as Yn, PROJECT_TOOLS as Yr, workspaceSections as Yt, panePids as Z, agentBadge as Zn, agentById as Zr, startSnapSweep as Zt, retryMaterialize as _, ensureAllCacheConfig as _i, readCache as _n, repoDefaultBranch as _r, lspWarm as _t, ensureUntrackedCache as a, checked as ai, refreshPrsBatch as an, manifest as ar, sessionInfo as at, sweepTrash as b, tmux as bi, inside as bn, configuredHosts as br, stopServers as bt, insertPendingWorkspace as c, publish as ci, noteActivity as cn, deleteSubscription as cr, tmuxWasStarted as ct, progress as d, subscriberCount as di, quotesPastes as dn, sendPush as dr, workspaceProcs as dt, parseAgentId as ei, markBranch as en, agentLabel as er, reopenSession as et, progressSince as f, all as fi, readHookPayload as fn, validSubscription as fr, killServers as ft, resumePendingWorkspaces as g, ownsBranchOf as gi, credentialStamp as gn, repoCatalog as gr, lspUses as gt, removeRepo as h, workspacePath as hi, blankRow as hn, repoBranches as hr, lspQueryOf as ht, deleteWorkspace as i, FRAME_HEADERS as ii, notePushActivity as in, iconSvg as ir, sendToSession as it, createSession as j, noteInterrupt as jn, changePref as jr, sharing as jt, clearTmuxStarted as k, noteActivity$1 as kn, agentChoices as kr, serverById as kt, listWorkspaces as l, publishJson as li, AGENTS as ln, pushPublicKey as lr, killWorkspaceProc as lt, queueMaterialize as m, get as mi, steerKeys as mn, pendingSsoOrgs as mr, lspQuery as mt, barePath as n, applyPrefChange as ni, dismissPr as nn, ACCENT_RE as nr, restartSession as nt, gcBares as o, httpError as oi, withoutDismissed as on, normalizeAccent as or, sessionStates as ot, pruneLaneBranch as p, db as pi, reportsWorking as pn, headOid as pr, lspDiagnostics as pt, noteConversation as q, summaryOf as qn, bornOut as qr, withinBudget as qt, createWorkspace as r, FRAME_ANCESTORS as ri, hotBatchMinMs as rn, getInstance as rr, retireSession as rt, getWorkspace as s, readBody as si, workspacePrs as sn, setInstance as sr, tmuxName as st, addRepo as t, toolById as ti, sectionFor as tn, agentMeta as tr, reopenable as tt, otherWorkspaceBranches as u, subscribe as ui, interruptKeys as un, saveSubscription as ur, portsByWorkspace as ut, revParse as v, TMUX_SOCKET as vi, writeCache as vn, DEFAULT_HOST as vr, runningServers as vt, ensureAllPushHooks as w, clearAgentPhase as wn, normalizeHost as wr, forgetProbes as wt, syncAgentsMd as x, config as xi, realInside as xn, ensureGitCredentials as xr, addCustomServer as xt, setWorkspaceStatus as y, git as yi, cleanSummary as yn, addHost as yr, stopAllServers as yt, killSession as z, onTurnEnd as zn, setPref as zr, removeTool as zt };
+export { panePids as $, agentBadge as $n, agentById as $r, startSnapSweep as $t, closedSession as A, lastTypedAt as An, WORKSPACE_PREFS as Ar, removeServer as At, killWorkspaceSessions as B, onPhaseChange as Bn, setDisabledAgents as Br, refreshGithub as Bt, workspaceBranches as C, config as Ci, realInside as Cn, ensureGitCredentials as Cr, addCustomServer as Ct, beginCreation as D, hookPhase as Dn, removeHost as Dr, installKey as Dt, agentCaller as E, clearAgentPhase as En, normalizeHost as Er, forgetProbes as Et, ensureTmuxServer as F, noteTurnFailed as Fn, disabledAgents as Fr, authGithub as Ft, markTmuxStarted as G, setExpecting as Gn, ghKnownHosts as Gr, patchIn as Gt, listPanes as H, onTurnFailed as Hn, setSetting as Hr, runStreaming as Ht, forgetPanes as I, noteTyped as In, enabledAgents as Ir, installAgent as It, noteConversation as J, settleQuietWorking as Jn, which as Jr, reviewWaiting as Jt, moveSession as K, setScrapedPhase as Kn, miseInstalls as Kr, readBlobAt as Kt, getSession as L, noteUserAnswered as Ln, getSetting as Lr, installMise as Lt, creationOf as M, noteBackground as Mn, allPrefs as Mr, serverList as Mt, descendantsOf as N, noteInterrupt as Nn, changePref as Nr, sharing as Nt, cleanEnv as O, hookReportedAt as On, unreachableRepos as Or, installServer as Ot, disposeSessions as P, notePermissionMode as Pn, deleteSetting as Pr, whileInstalling as Pt, paneJobs as Q, turnSince as Qn, TOOLS as Qr, setPoints as Qt, interruptSession as R, notifyEventOn as Rn, isKnownAgent as Rr, installTool as Rt, withProgressOp as S, tmux as Si, inside as Sn, configuredHosts as Sr, stopServers as St, hookToken as T, withLock as Ti, agentPhase as Tn, isValidHost as Tr, forgetCustomServer as Tt, listPanesWithin as U, sessionWatched as Un, discoverAgents as Ur, updateTool as Ut, launchDir as V, onTurnEnd as Vn, setPref as Vr, removeTool as Vt, listSessions as W, setAgentPhase as Wn, doctor as Wr, fileChanges as Wt, onSessionDispose as X, turnPhase as Xn, firewallProbe as Xr, workspaceDiff as Xt, notifySessionsChanged as Y, summaryOf as Yn, bornOut as Yr, withinBudget as Yt, ownWorkspaceOnly as Z, turnSettling as Zn, PROJECT_TOOLS as Zr, workspaceSections as Zt, retryMaterialize as _, workspacePath as _i, blankRow as _n, repoBranches as _r, lspQueryOf as _t, ensureUntrackedCache as a, FRAME_ANCESTORS as ai, hotBatchMinMs as an, getInstance as ar, retireSession as at, sweepTrash as b, TMUX_SOCKET as bi, writeCache as bn, DEFAULT_HOST as br, runningServers as bt, insertPendingWorkspace as c, httpError as ci, withoutDismissed as cn, normalizeAccent as cr, sessionStates as ct, progress as d, publishJson as di, AGENTS as dn, pushPublicKey as dr, killWorkspaceProc as dt, agentLabel$1 as ei, diffStamp as en, agentFamily as er, pasteToSession as et, progressSince as f, subscribe as fi, interruptKeys as fn, saveSubscription as fr, portsByWorkspace as ft, resumePendingWorkspaces as g, get as gi, steerKeys as gn, pendingSsoOrgs as gr, lspQuery as gt, removeRepo as h, db as hi, reportsWorking as hn, headOid as hr, lspDiagnostics as ht, deleteWorkspace as i, applyPrefChange as ii, dismissPr as in, ACCENT_RE as ir, restartSession as it, createSession as j, noteActivity$1 as jn, agentChoices as jr, serverById as jt, clearTmuxStarted as k, interruptedSinceReport as kn, PREF_MAX as kr, lspEnabled as kt, listWorkspaces as l, readBody as li, workspacePrs as ln, setInstance as lr, tmuxName as lt, queueMaterialize as m, all as mi, readHookPayload as mn, validSubscription as mr, killServers as mt, barePath as n, parseAgentId as ni, markBranch as nn, agentLabel as nr, reopenSession as nt, gcBares as o, FRAME_HEADERS as oi, notePushActivity as on, iconSvg as or, sendToSession as ot, pruneLaneBranch as p, subscriberCount as pi, quotesPastes as pn, sendPush as pr, workspaceProcs as pt, newSessionArgs as q, setSessionViewers as qn, miseVersions as qr, readFileAt as qt, createWorkspace as r, toolById as ri, sectionFor as rn, agentMeta as rr, reopenable as rt, getWorkspace as s, checked as si, refreshPrsBatch as sn, manifest as sr, sessionInfo as st, addRepo as t, catalogPin as ti, commentFolder as tn, agentFromCommand as tr, renameSession as tt, otherWorkspaceBranches as u, publish as ui, noteActivity as un, deleteSubscription as ur, tmuxWasStarted as ut, revParse as v, ownsBranchOf as vi, credentialStamp as vn, repoCatalog as vr, lspUses as vt, ensureAllPushHooks as w, swr as wi, activityOf as wn, forgetToken as wr, allServers as wt, syncAgentsMd as x, git as xi, cleanSummary as xn, addHost as xr, stopAllServers as xt, setWorkspaceStatus as y, ensureAllCacheConfig as yi, readCache as yn, repoDefaultBranch as yr, lspWarm as yt, killSession as z, onFinished as zn, preferredAgent as zr, logoutGithub as zt };

package/dist/_BOUuiLtz.js

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

package/dist/_C-c452mk.js

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