@dylanpiercey/work 0.2.28 → 0.2.30

package/bin/cli/session.mjs

@@ -3,6 +3,7 @@
 // other sessions — starting one or a fan-out of them, messaging one and
 // waiting on replies, closing them (server/messages.ts, server/team.ts).
 import path from "node:path";
+import { duration } from "../../lib/usage/format.mjs";
 import { makeTopics, topicRepos } from "./topic.mjs";
 
 /** More sessions than this running in one workspace is an agent starting
@@ -46,6 +47,7 @@ async function sessionsOf(ctx, wsId) {
     parent: s.parent_id || null,
     waitingOn: s.messages?.waitingOn ?? [],
     queued: s.messages?.queued ?? 0,
+    turnSince: s.state?.turnSince ?? null,
     self: s.id === me,
   }));
   const ids = new Set(rows.map((s) => s.id));
@@ -60,8 +62,14 @@ async function sessionsOf(ctx, wsId) {
   return out;
 }
 
+/** How long a turn has run: seconds under a minute, then coarse. */
+function turnText(ms) {
+  return `${ms < 60_000 ? `${Math.round(ms / 1000)}s` : duration(ms)} into its turn`;
+}
+
 function sessionLine(ctx, s) {
   const notes = [
+    s.turnSince && turnText(Date.now() - s.turnSince),
     s.waitingOn.length && `waiting on ${s.waitingOn.join(", ")}`,
     s.queued && `${s.queued} queued for it`,
     s.self && "this session",
@@ -86,15 +94,11 @@ async function textOf(value) {
   return Buffer.concat(chunks).toString("utf8").replace(/\n$/, "");
 }
 
-/** What became of a message, for the sender. */
-function sentText(id, r) {
-  const lines = [
-    `${r.reopened ? `reopened ${id} on its conversation; ` : ""}${
-      r.delivered
-        ? `sent to ${id}`
-        : `queued for ${id} (${r.queued}): typed in once it is at its prompt`
-    }`,
-  ];
+/** What became of a message, for the sender: whether it went in, and
+ * last — where `| tail -1` keeps it — how long it may wait and how to
+ * reach the session sooner. */
+function sentText(id, r, asked) {
+  const lines = [];
   if (r.wantsReply)
     lines.push(
       `Its last message, as that turn ends, comes back to you as a prompt: end your turn to wait for it, or run \`work session wait ${id}\`.`,
@@ -103,6 +107,30 @@ function sentText(id, r) {
     lines.push(
       "A reply it sends before then answers what it is on now: each reply names the message of yours it answers.",
     );
+  const reopened = r.reopened ? `reopened ${id} on its conversation; ` : "";
+  const stopped = r.interrupted ? `stopped ${id}'s turn; ` : "";
+  if (r.midTurn)
+    lines.push(
+      `${stopped}typed into ${id}'s turn under way: it gets this at its next step, after the tool call it is on`,
+    );
+  else if (r.delivered) lines.push(`${reopened}${stopped}sent to ${id}`);
+  else {
+    const wait = [
+      r.queued,
+      r.turnMs !== null && turnText(r.turnMs),
+      r.ahead && `${r.ahead} more queued with it`,
+    ].filter(Boolean);
+    const sooner = !r.queued.startsWith("it is working")
+      ? ""
+      : r.steers && !asked.now
+        ? ` To reach it sooner: \`work session send ${id} --now "…"\` (into the turn, at its next step) or --interrupt (stops the turn first).`
+        : !r.steers && r.interrupts && !asked.interrupt
+          ? ` Its CLI takes no message mid-turn: --interrupt stops the turn to send it now.`
+          : "";
+    lines.push(
+      `${reopened}${stopped}queued for ${id} (${wait.join("; ")}): typed in once it is at its prompt${asked.now && r.steers ? ", or into its turn once nothing stands in the way" : ""}.${sooner}`,
+    );
+  }
   return lines.join("\n");
 }
 
@@ -180,7 +208,8 @@ export const commands = [
   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>/…).
 work session list [id|name] [--json]
-  The workspace's sessions, this one marked.
+  The workspace's sessions, this one marked, with how long each has been
+  in the turn under way and how many messages are queued for it.
 work session title "<name>" [--session <id>]
   Name a session in the session list (empty clears it).
 work session new [--agent <id>] [--title "<name>"] [--prompt "<text>"|-] [--no-reply] [--keep] [--topic <name> [--repo <repo>…] [--install]] [--workspace <id|name>] [--force]
@@ -219,15 +248,22 @@ work session retry <member>
 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.
-work session send <id> "<text>"|- [--no-reply]
+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 turn under way, a question it asks,
-  or a draft someone is typing. From an agent's session it wants a reply
-  unless --no-reply: the recipient's last message as that turn ends,
-  typed into this session as a prompt of its own. End your turn to wait
-  for it. One sent mid-turn is answered a turn later: the reply that
-  comes first answers what it was on, and each reply names the message
-  of yours it answers and those still queued. A session closed for being
+  it is at its prompt — never into a question it asks or a draft someone
+  is typing. From an agent's session it wants a reply unless --no-reply:
+  the recipient's last message as that turn ends, typed into this
+  session as a prompt of its own. End your turn to wait for it. A turn
+  can run for hours, and one sent meanwhile waits for its end, then is
+  answered a turn later: the reply that comes first answers what it was
+  on, and each reply names the message of yours it answers and those
+  still queued. A correction or a stop should not wait: --now types it
+  into the turn under way, which its CLI hands the agent at its next
+  step (after the tool call it is on), and that turn's end answers it;
+  --interrupt stops the turn first, for one the next step is too late
+  for or whose CLI takes nothing mid-turn (Grok). What is queued for it
+  goes in with it. The last line printed says whether it went in, and
+  if not, how long the turn it waits out has run. A session closed for being
   done is reopened on its own conversation first, where its CLI can
   resume one (Claude, Codex); otherwise the send says to start a new one.
   A file's path says more than its text pasted in. An agent in
@@ -449,14 +485,23 @@ work session kill --done
           const [id, ...words] = rest;
           const text = await textOf(words.join(" "));
           if (!id || !text)
-            ctx.die('usage: work session send <id> "<text>"|- [--no-reply]');
+            ctx.die(
+              'usage: work session send <id> "<text>"|- [--no-reply] [--now|--interrupt]',
+            );
           const me = process.env.WORK_SESSION_ID;
+          const asked = {
+            now: ctx.has("--now"),
+            interrupt: ctx.has("--interrupt"),
+          };
           const r = await ctx.api.post(`/api/sessions/${id}/messages`, {
             text,
             ...(me ? { from: me } : {}),
             reply: !ctx.has("--no-reply"),
+            ...asked,
           });
-          return ctx.out({ id, ...r }, (r) => console.log(sentText(id, r)));
+          return ctx.out({ id, ...r }, (r) =>
+            console.log(sentText(id, r, asked)),
+          );
         }
         case "wait": {
           const me = sessionId(ctx);

package/dist/_CeTAKoPH.js

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

package/dist/{_DQbVrULO.js → _Chg81Eud.js}

@@ -736,6 +736,13 @@ var STEPS = [
         );
       `);
 		}
+	},
+	{
+		version: 10,
+		name: "messages that go mid-turn",
+		up(db) {
+			db.exec("ALTER TABLE session_messages ADD COLUMN urgent INTEGER NOT NULL DEFAULT 0");
+		}
 	}
 ];
 var LATEST = STEPS.at(-1).version;
@@ -9160,6 +9167,9 @@ var typedAt = /* @__PURE__ */ new Map();
 /** What each session's turn is doing, from its last tool call ("Bash:
 * pnpm test"): the line a team view shows for a member at work. */
 var activities = /* @__PURE__ */ new Map();
+/** When each session's turn began, while one runs: how long a message
+* that waits for its end has to wait (server/messages). */
+var turnStarts = /* @__PURE__ */ new Map();
 /** Each session's permission mode, as its hooks last reported it
 * (`permission_mode`): what a session it starts runs in. */
 var modes = /* @__PURE__ */ new Map();
@@ -9167,6 +9177,9 @@ var modes = /* @__PURE__ */ new Map();
 var finishedListeners = /* @__PURE__ */ new Set();
 /** Told of each turn's end that stayed the end (`onTurnEnd`). */
 var turnEndListeners = /* @__PURE__ */ new Set();
+/** The last messages of each session's turn ends that did not stay the
+* end (it went straight back to work), until one does. */
+var foldedMessages = /* @__PURE__ */ new Map();
 /** A turn's end is pushed once it has stayed ended this long. Stop fires
 * again each time something sends the agent back to work (a stop hook
 * that continues it, a goal loop, background subagents reporting in), and
@@ -9233,14 +9246,18 @@ function noteBackground(sessionId, work) {
 	});
 }
 /** A turn's end once it has stayed the end (`DONE_SETTLE_MS`), with its
-* last message (undefined: the CLI reports none). A listener returns
-* whether it passed the end on to another session. */
+* last message (undefined: the CLI reports none) and those of the ends
+* before it that did not stay the end (`earlier`: a message typed in as
+* the agent wrote its answer can be a turn of its own straight after). A
+* listener returns whether it passed the end on to another session. */
 function onTurnEnd(fn) {
 	turnEndListeners.add(fn);
 }
 function endTurn(sessionId) {
+	const earlier = foldedMessages.get(sessionId) ?? [];
+	foldedMessages.delete(sessionId);
 	let told = false;
-	for (const fn of turnEndListeners) told = fn(sessionId, lastMessages.get(sessionId)) || told;
+	for (const fn of turnEndListeners) told = fn(sessionId, lastMessages.get(sessionId), earlier) || told;
 	return told;
 }
 /** A session's job is done: its turn ended and stayed ended, answering
@@ -9288,11 +9305,17 @@ function noteTyped(sessionId) {
 function lastTypedAt(sessionId) {
 	return typedAt.get(sessionId) ?? 0;
 }
+/** When the session's turn under way began (undefined: at its prompt). */
+function turnSince(sessionId) {
+	return turnStarts.get(sessionId);
+}
 function cancelDone(sessionId) {
 	const timer = pendingDone.get(sessionId);
 	if (!timer) return;
 	clearTimeout(timer);
 	pendingDone.delete(sessionId);
+	const message = lastMessages.get(sessionId);
+	if (message) foldedMessages.set(sessionId, [...foldedMessages.get(sessionId) ?? [], message]);
 }
 /** What the session's hooks last said, apart from the scraper: the
 * turn's phase, else working while its background work runs. */
@@ -9397,11 +9420,13 @@ function clearAgentPhase(sessionId) {
 	cancelDone(sessionId);
 	summaries.delete(sessionId);
 	lastMessages.delete(sessionId);
+	foldedMessages.delete(sessionId);
 	typedAt.delete(sessionId);
 	modes.delete(sessionId);
 	activities.delete(sessionId);
 	reportedAt.delete(sessionId);
 	interruptedAt.delete(sessionId);
+	turnStarts.delete(sessionId);
 	if (!phases.has(sessionId) && !scraped.has(sessionId) && !background.has(sessionId)) return;
 	applyChange(sessionId, () => {
 		phases.delete(sessionId);
@@ -9427,6 +9452,8 @@ function agentPhase(sessionId) {
 function applyChange(sessionId, mutate, force = false) {
 	const before = agentPhase(sessionId);
 	mutate();
+	if (!turnPhase(sessionId)) turnStarts.delete(sessionId);
+	else if (!turnStarts.has(sessionId)) turnStarts.set(sessionId, Date.now());
 	const after = agentPhase(sessionId);
 	if (before === after && !force) return;
 	publishChange(sessionId);
@@ -9437,7 +9464,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("./_CkGqrA7b.js").then((m) => m.notifySessionsChanged(workspaceId));
+		import("./_ENzyVrzA.js").then((m) => m.notifySessionsChanged(workspaceId));
 		return;
 	}
 	publish("sessions.changed");
@@ -10266,6 +10293,8 @@ var claude = {
 	modeFlags: (mode) => MODES.has(mode) ? ["--permission-mode", mode] : [],
 	headless: (args) => hasArg(args, "-p", "--print"),
 	resumeFlags: (id) => ["--resume", id],
+	steerKeys: ["Enter"],
+	interruptKeys: ["Escape"],
 	envPrefixes: ["CLAUDE", "AI_AGENT"],
 	startupQuestions: [{
 		screen: /Is this a project you created or one you trust/,
@@ -10491,6 +10520,8 @@ var codex = {
 	meta: meta$5,
 	launchFlags,
 	resumeFlags: (id) => ["resume", id],
+	steerKeys: ["Enter"],
+	interruptKeys: ["Escape"],
 	reportsWorking: () => true,
 	headless: (args) => hasArg(args, "exec", "e", "review"),
 	envPrefixes: ["CODEX_"],
@@ -10756,6 +10787,8 @@ var copilot = {
 		asks: "which sessions to restore"
 	}],
 	reportsWorking: () => true,
+	steerKeys: ["Enter"],
+	interruptKeys: ["C-c"],
 	headless: (args) => hasArg(args, "-p", "--prompt"),
 	envPrefixes: ["COPILOT_"],
 	readHook: readHook$4,
@@ -10933,6 +10966,8 @@ var cursor = {
 		pluginDir()
 	],
 	headless: (args) => hasArg(args, "-p", "--print"),
+	steerKeys: ["Enter", "Enter"],
+	interruptKeys: ["Escape"],
 	readHook: readHook$3,
 	readyScreen: /Plan, search, build anything|Add a follow-up/,
 	usage: () => cursorRow().then((row) => [row]),
@@ -11232,6 +11267,7 @@ var grok = {
 	},
 	reportsWorking: registered,
 	promptAsArgv: true,
+	interruptKeys: ["C-c"],
 	headless: (args) => hasArg(args, "-p", "--single", "--prompt-file", "--prompt-json", "agent"),
 	envPrefixes: ["GROK_"],
 	readHook: readHook$2,
@@ -11408,6 +11444,8 @@ var opencode = {
 	readyScreen: /Ask anything/,
 	launchEnv: () => ({ OPENCODE_CONFIG_CONTENT: pluginConfig() }),
 	reportsWorking: installed$1,
+	steerKeys: ["Enter"],
+	interruptKeys: ["Escape", "Escape"],
 	headless: (args) => hasArg(args, "run"),
 	envPrefixes: ["OPENCODE_"],
 	readHook: readHook$1
@@ -11529,6 +11567,8 @@ var AGENTS = [
 		meta,
 		launchFlags: () => ["-e", extensionFile()],
 		reportsWorking: installed,
+		steerKeys: ["Enter"],
+		interruptKeys: ["Escape"],
 		headless: (args) => hasArg(args, "-p", "--print", "--mode"),
 		envPrefixes: ["PI_"],
 		readHook
@@ -11577,6 +11617,15 @@ function startupQuestion(id, screen) {
 function readyScreen(id) {
 	return agentFor(id)?.readyScreen;
 }
+/** The keys that hand a pasted message to the turn under way
+* (`steerKeys`), if its CLI takes one mid-turn. */
+function steerKeys(id) {
+	return agentFor(id)?.steerKeys;
+}
+/** The keys that stop a turn under way (`interruptKeys`), if known. */
+function interruptKeys(id) {
+	return agentFor(id)?.interruptKeys;
+}
 /** Cold launch takes the first prompt as argv rather than a paste. */
 function promptAsArgv(id) {
 	return agentFor(id)?.promptAsArgv ?? false;
@@ -17519,7 +17568,7 @@ function notifySessionsChanged(workspaceId) {
 async function emitSessionsChanged(workspaceId) {
 	try {
 		const states = await sessionStates();
-		const { teamsOf } = await import("./_Cg63x2E_.js");
+		const { teamsOf } = await import("./_CeTAKoPH.js");
 		publish("sessions.changed", {
 			workspaceId,
 			sessions: listSessions(workspaceId).map((s) => ({
@@ -17541,7 +17590,7 @@ 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) {
+async function sendToSession(id, raw, size, submit = ["Enter"]) {
 	const text = raw.replace(PASTE_UNSAFE, "");
 	const session = getSession(id);
 	if (!session) throw new Error("unknown session");
@@ -17607,13 +17656,48 @@ async function sendToSession(id, raw, size) {
 		name
 	], env);
 	await waitStill(name, env, PASTE_SETTLE_MS);
-	await tmux([
-		"send-keys",
-		"-t",
-		name,
-		"Enter"
-	], env);
+	for (const [i, key] of submit.entries()) {
+		if (i) await sleep(KEY_GAP_MS);
+		await tmux([
+			"send-keys",
+			"-t",
+			name,
+			key
+		], env);
+	}
+}
+/** Between one submit key and the next. */
+var KEY_GAP_MS = 400;
+/** Stop the turn a session's CLI is on (`--interrupt`) with the family's
+* keys, and give it a moment to be back at its prompt. False: its family
+* names none, or its pane is gone. Noted as the user's own Esc is, so a
+* turn that ends with no hook to say so reads as ended once the pane goes
+* still (scraper.ts). */
+async function interruptSession(id) {
+	const session = getSession(id);
+	const keys = interruptKeys(session?.agent);
+	if (!session || !keys) return false;
+	const name = tmuxName(id);
+	const env = cleanEnv();
+	noteInterrupt(id);
+	try {
+		for (const [i, key] of keys.entries()) {
+			if (i) await sleep(KEY_GAP_MS);
+			await tmux([
+				"send-keys",
+				"-t",
+				name,
+				key
+			], env);
+		}
+	} catch {
+		return false;
+	}
+	await waitStill(name, env, INTERRUPT_SETTLE_MS);
+	return true;
 }
+/** Upper bound on a CLI redrawing its prompt after an interrupt. */
+var INTERRUPT_SETTLE_MS = 2e3;
 /** Start a session's process in a tmux session of its own, detached, and
 * wait for its CLI to take input: the pane starts as a login shell that
 * then execs the agent, and the agent takes a while more to draw its
@@ -17638,7 +17722,8 @@ async function sessionStates(maxAgeMs = 0) {
 		result[id] = {
 			alive: true,
 			phase: agentPhase(id),
-			command: run ? void 0 : command
+			command: run ? void 0 : command,
+			turnSince: turnSince(id)
 		};
 	}
 	return result;
@@ -19104,7 +19189,9 @@ ${repoLines}
   running as you do (it asks the user nothing you would not), and
   \`work session send <id> "<text>"\` messages one; its last message, as that
   turn ends, comes back to you as a prompt: end your turn to wait for it (or
-  \`work session wait\`). \`work session fanout --agent <id>… --prompt "<task {}>" <item>…\`
+  \`work session wait\`). 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>…\`
   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
@@ -19128,4 +19215,4 @@ ${repoLines}
 `;
 }
 //#endregion
-export { reopenable as $, saveSubscription as $n, subscriberCount as $r, notePushActivity as $t, closedSession as A, onTurnEnd as An, discoverAgents as Ar, installAgent as At, launchDir as B, agentBadge as Bn, agentLabel$1 as Br, readBlobAt as Bt, workspaceBranches as C, noteInterrupt as Cn, enabledAgents as Cr, lspEnabled as Ct, beginCreation as D, notifyEventOn as Dn, setDisabledAgents as Dr, sharing as Dt, agentCaller as E, noteUserAnswered as En, preferredAgent as Er, serverList as Et, ensureTmuxServer as F, setSessionViewers as Fn, which as Fr, removeTool as Ft, newSessionArgs as G, ACCENT_RE as Gn, FRAME_ANCESTORS as Gr, setPoints as Gt, listPanesWithin as H, agentFromCommand as Hn, parseAgentId as Hr, reviewWaiting as Ht, forgetPanes as I, settleQuietWorking as In, firewallProbe as Ir, runStreaming as It, onSessionDispose as J, manifest as Jn, httpError as Jr, commentFolder as Jt, noteConversation as K, getInstance as Kn, FRAME_HEADERS as Kr, startSnapSweep as Kt, getSession as L, summaryOf as Ln, PROJECT_TOOLS as Lr, updateTool as Lt, creationOf as M, setAgentPhase as Mn, ghKnownHosts as Mr, installTool as Mt, descendantsOf as N, setExpecting as Nn, miseInstalls as Nr, logoutGithub as Nt, cleanEnv as O, onFinished as On, setPref as Or, whileInstalling as Ot, disposeSessions as P, setScrapedPhase as Pn, miseVersions as Pr, refreshGithub as Pt, reopenSession as Q, pushPublicKey as Qn, subscribe as Qr, hotBatchMinMs as Qt, killSession as R, turnPhase as Rn, TOOLS as Rr, MAX_PREVIEW_BYTES as Rt, withProgressOp as S, noteBackground as Sn, disabledAgents as Sr, installServer as St, hookToken as T, noteTyped as Tn, isKnownAgent as Tr, serverById as Tt, listSessions as U, agentLabel as Un, toolById as Ur, workspaceDiff as Ut, listPanes as V, agentFamily as Vn, catalogPin as Vr, readFileAt as Vt, markTmuxStarted as W, agentMeta as Wn, applyPrefChange as Wr, workspaceSections as Wt, panePids as X, setInstance as Xn, publish as Xr, sectionFor as Xt, ownWorkspaceOnly as Y, normalizeAccent as Yn, readBody as Yr, markBranch as Yt, renameSession as Z, deleteSubscription as Zn, publishJson as Zr, dismissPr as Zt, retryMaterialize as _, hookPhase as _n, WORKSPACE_PREFS as _r, addCustomServer as _t, ensureUntrackedCache as a, ensureAllCacheConfig as ai, readHookPayload as an, repoCatalog as ar, killWorkspaceProc as at, sweepTrash as b, lastTypedAt as bn, changePref as br, forgetProbes as bt, insertPendingWorkspace as c, tmux as ci, credentialStamp as cn, addHost as cr, killServers as ct, progress as d, withLock as di, cleanSummary as dn, forgetToken as dr, lspQueryOf as dt, all as ei, refreshPrsBatch as en, sendPush as er, retireSession as et, progressSince as f, inside as fn, isValidHost as fr, lspUses as ft, resumePendingWorkspaces as g, clearAgentPhase as gn, PREF_MAX as gr, stopServers as gt, removeRepo as h, agentPhase as hn, unreachableRepos as hr, stopAllServers as ht, deleteWorkspace as i, ownsBranchOf as ii, AGENTS as in, repoBranches as ir, tmuxWasStarted as it, createSession as j, sessionWatched as jn, doctor as jr, installMise as jt, clearTmuxStarted as k, onPhaseChange as kn, setSetting as kr, authGithub as kt, listWorkspaces as l, config as li, readCache as ln, configuredHosts as lr, lspDiagnostics as lt, queueMaterialize as m, activityOf as mn, removeHost as mr, runningServers as mt, barePath as n, get as ni, workspacePrs as nn, headOid as nr, sessionStates as nt, gcBares as o, TMUX_SOCKET as oi, reportsWorking as on, repoDefaultBranch as or, portsByWorkspace as ot, pruneLaneBranch as p, realInside as pn, normalizeHost as pr, lspWarm as pt, notifySessionsChanged as q, iconSvg as qn, checked as qr, diffStamp as qt, createWorkspace as r, workspacePath as ri, noteActivity as rn, pendingSsoOrgs as rr, tmuxName as rt, getWorkspace as s, git as si, blankRow as sn, DEFAULT_HOST as sr, workspaceProcs as st, addRepo as t, db as ti, withoutDismissed as tn, validSubscription as tr, sendToSession as tt, otherWorkspaceBranches as u, swr as ui, writeCache as un, ensureGitCredentials as ur, lspQuery as ut, revParse as v, hookReportedAt as vn, agentChoices as vr, allServers as vt, ensureAllPushHooks as w, notePermissionMode as wn, getSetting as wr, removeServer as wt, syncAgentsMd as x, noteActivity$1 as xn, deleteSetting as xr, installKey as xt, setWorkspaceStatus as y, interruptedSinceReport as yn, allPrefs as yr, forgetCustomServer as yt, killWorkspaceSessions as z, turnSettling as zn, agentById as zr, fileChanges as zt };
+export { reopenSession as $, normalizeAccent as $n, readBody as $r, hotBatchMinMs as $t, closedSession as A, notifyEventOn as An, preferredAgent as Ar, authGithub as At, killWorkspaceSessions as B, summaryOf as Bn, firewallProbe as Br, fileChanges as Bt, workspaceBranches as C, lastTypedAt as Cn, allPrefs as Cr, installServer as Ct, beginCreation as D, notePermissionMode as Dn, enabledAgents as Dr, serverList as Dt, agentCaller as E, noteInterrupt as En, disabledAgents as Er, serverById as Et, ensureTmuxServer as F, setAgentPhase as Fn, doctor as Fr, refreshGithub as Ft, markTmuxStarted as G, agentFamily as Gn, catalogPin as Gr, workspaceSections as Gt, listPanes as H, turnSettling as Hn, TOOLS as Hr, readFileAt as Ht, forgetPanes as I, setExpecting as In, ghKnownHosts as Ir, removeTool as It, notifySessionsChanged as J, agentMeta as Jn, applyPrefChange as Jr, diffStamp as Jt, newSessionArgs as K, agentFromCommand as Kn, parseAgentId as Kr, setPoints as Kt, getSession as L, setScrapedPhase as Ln, miseInstalls as Lr, runStreaming as Lt, creationOf as M, onPhaseChange as Mn, setPref as Mr, installMise as Mt, descendantsOf as N, onTurnEnd as Nn, setSetting as Nr, installTool as Nt, cleanEnv as O, noteTyped as On, getSetting as Or, sharing as Ot, disposeSessions as P, sessionWatched as Pn, discoverAgents as Pr, logoutGithub as Pt, renameSession as Q, manifest as Qn, httpError as Qr, dismissPr as Qt, interruptSession as R, setSessionViewers as Rn, miseVersions as Rr, updateTool as Rt, withProgressOp as S, interruptedSinceReport as Sn, agentChoices as Sr, installKey as St, hookToken as T, noteBackground as Tn, deleteSetting as Tr, removeServer as Tt, listPanesWithin as U, turnSince as Un, agentById as Ur, reviewWaiting as Ut, launchDir as V, turnPhase as Vn, PROJECT_TOOLS as Vr, readBlobAt as Vt, listSessions as W, agentBadge as Wn, agentLabel$1 as Wr, workspaceDiff as Wt, ownWorkspaceOnly as X, getInstance as Xn, FRAME_HEADERS as Xr, markBranch as Xt, onSessionDispose as Y, ACCENT_RE as Yn, FRAME_ANCESTORS as Yr, commentFolder as Yt, panePids as Z, iconSvg as Zn, checked as Zr, sectionFor as Zt, retryMaterialize as _, activityOf as _n, normalizeHost as _r, stopServers as _t, ensureUntrackedCache as a, db as ai, AGENTS as an, validSubscription as ar, tmuxWasStarted as at, sweepTrash as b, hookPhase as bn, PREF_MAX as br, forgetCustomServer as bt, insertPendingWorkspace as c, ownsBranchOf as ci, reportsWorking as cn, repoBranches as cr, workspaceProcs as ct, progress as d, git as di, credentialStamp as dn, DEFAULT_HOST as dr, lspQuery as dt, publish as ei, notePushActivity as en, setInstance as er, reopenable as et, progressSince as f, tmux as fi, readCache as fn, addHost as fr, lspQueryOf as ft, resumePendingWorkspaces as g, realInside as gn, isValidHost as gr, stopAllServers as gt, removeRepo as h, withLock as hi, inside as hn, forgetToken as hr, runningServers as ht, deleteWorkspace as i, all as ii, noteActivity as in, sendPush as ir, tmuxName as it, createSession as j, onFinished as jn, setDisabledAgents as jr, installAgent as jt, clearTmuxStarted as k, noteUserAnswered as kn, isKnownAgent as kr, whileInstalling as kt, listWorkspaces as l, ensureAllCacheConfig as li, steerKeys as ln, repoCatalog as lr, killServers as lt, queueMaterialize as m, swr as mi, cleanSummary as mn, ensureGitCredentials as mr, lspWarm as mt, barePath as n, subscribe as ni, withoutDismissed as nn, pushPublicKey as nr, sendToSession as nt, gcBares as o, get as oi, interruptKeys as on, headOid as or, killWorkspaceProc as ot, pruneLaneBranch as p, config as pi, writeCache as pn, configuredHosts as pr, lspUses as pt, noteConversation as q, agentLabel as qn, toolById as qr, startSnapSweep as qt, createWorkspace as r, subscriberCount as ri, workspacePrs as rn, saveSubscription as rr, sessionStates as rt, getWorkspace as s, workspacePath as si, readHookPayload as sn, pendingSsoOrgs as sr, portsByWorkspace as st, addRepo as t, publishJson as ti, refreshPrsBatch as tn, deleteSubscription as tr, retireSession as tt, otherWorkspaceBranches as u, TMUX_SOCKET as ui, blankRow as un, repoDefaultBranch as ur, lspDiagnostics as ut, revParse as v, agentPhase as vn, removeHost as vr, addCustomServer as vt, ensureAllPushHooks as w, noteActivity$1 as wn, changePref as wr, lspEnabled as wt, syncAgentsMd as x, hookReportedAt as xn, WORKSPACE_PREFS as xr, forgetProbes as xt, setWorkspaceStatus as y, clearAgentPhase as yn, unreachableRepos as yr, allServers as yt, killSession as z, settleQuietWorking as zn, which as zr, MAX_PREVIEW_BYTES as zt };