@dylanpiercey/work 0.2.19 → 0.2.20

package/dist/_DrEeyoLF.js

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

package/dist/_E0fWorAK.js

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

package/dist/{_CsokArOR.js → _Hb3LeA5Q.js}

@@ -500,6 +500,75 @@ var STEPS = [
 
         CREATE INDEX session_messages_to ON session_messages(to_session);
         CREATE INDEX session_messages_from ON session_messages(from_session);
+      `);
+		}
+	},
+	{
+		version: 5,
+		name: "session teams",
+		up(db) {
+			db.exec(`
+        ALTER TABLE sessions ADD COLUMN launch_dir TEXT;
+        ALTER TABLE sessions ADD COLUMN launch_mode TEXT;
+        ALTER TABLE sessions ADD COLUMN summary TEXT;
+        ALTER TABLE sessions ADD COLUMN keep INTEGER NOT NULL DEFAULT 0;
+        ALTER TABLE sessions ADD COLUMN answered_at TEXT;
+        UPDATE sessions SET answered_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+          WHERE parent_id IS NOT NULL
+            AND id NOT IN (SELECT to_session FROM session_messages);
+
+        CREATE TABLE plans (
+          id TEXT PRIMARY KEY,
+          workspace_id TEXT NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
+          owner TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+          name TEXT NOT NULL,
+          phases TEXT NOT NULL DEFAULT '[]',
+          created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+          done_at TEXT
+        );
+
+        CREATE TABLE plan_log (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          plan_id TEXT NOT NULL REFERENCES plans(id) ON DELETE CASCADE,
+          text TEXT NOT NULL,
+          at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+        );
+
+        CREATE TABLE session_groups (
+          id TEXT PRIMARY KEY,
+          workspace_id TEXT NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
+          owner TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+          plan_id TEXT REFERENCES plans(id) ON DELETE SET NULL,
+          phase TEXT,
+          title TEXT NOT NULL,
+          parallel INTEGER NOT NULL DEFAULT 4,
+          fan_in INTEGER NOT NULL DEFAULT 1,
+          close_done INTEGER NOT NULL DEFAULT 0,
+          keep INTEGER NOT NULL DEFAULT 0,
+          created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+        );
+
+        CREATE TABLE group_members (
+          id TEXT PRIMARY KEY,
+          group_id TEXT NOT NULL REFERENCES session_groups(id) ON DELETE CASCADE,
+          ord INTEGER NOT NULL,
+          session_id TEXT REFERENCES sessions(id) ON DELETE SET NULL,
+          agent TEXT NOT NULL,
+          title TEXT NOT NULL,
+          prompt TEXT NOT NULL,
+          launch_dir TEXT,
+          state TEXT NOT NULL DEFAULT 'queued' CHECK (state IN ('queued', 'running', 'done', 'closed')),
+          note TEXT,
+          summary TEXT,
+          attempts INTEGER NOT NULL DEFAULT 0,
+          started_at TEXT,
+          done_at TEXT
+        );
+
+        CREATE INDEX group_members_group ON group_members(group_id);
+        CREATE INDEX group_members_session ON group_members(session_id);
+
+        ALTER TABLE session_messages ADD COLUMN group_id TEXT REFERENCES session_groups(id) ON DELETE SET NULL;
       `);
 		}
 	}
@@ -8249,6 +8318,14 @@ var lastMessages = /* @__PURE__ */ new Map();
 var expecting = /* @__PURE__ */ new Set();
 /** When someone last typed into each session's pane from a page. */
 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();
+/** 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();
+/** Told when a session's job is done (`onFinished`). */
+var finishedListeners = /* @__PURE__ */ new Set();
 /** Told of each turn's end that stayed the end (`onTurnEnd`). */
 var turnEndListeners = /* @__PURE__ */ new Set();
 /** A turn's end is pushed once it has stayed ended this long. Stop fires
@@ -8271,13 +8348,17 @@ function setAgentPhase(sessionId, phase, reason, summary, message) {
 	if (phase === "waiting" && reason === "done") {
 		const failed = phases.get(sessionId) === "waiting" && reasons.get(sessionId) === "attention";
 		if (summary) summaries.set(sessionId, summary);
+		activities.delete(sessionId);
 		if (message) lastMessages.set(sessionId, message);
 		else lastMessages.delete(sessionId);
 		if (phases.has(sessionId)) applyChange(sessionId, () => dropHook(sessionId));
 		if (!background.has(sessionId)) pendingDone.set(sessionId, setTimeout(() => {
 			pendingDone.delete(sessionId);
 			const answered = endTurn(sessionId);
-			if (!failed && !answered && !expecting.has(sessionId)) notify(sessionId, "done");
+			if (!failed && !answered && !expecting.has(sessionId)) {
+				for (const fn of finishedListeners) fn(sessionId);
+				notify(sessionId, "done");
+			}
 		}, DONE_SETTLE_MS));
 		return;
 	}
@@ -8323,6 +8404,11 @@ function endTurn(sessionId) {
 	for (const fn of turnEndListeners) told = fn(sessionId, lastMessages.get(sessionId)) || told;
 	return told;
 }
+/** A session's job is done: its turn ended and stayed ended, answering
+* nobody, with nothing it waits on — the moment a Finished is pushed. */
+function onFinished(fn) {
+	finishedListeners.add(fn);
+}
 /** A turn's end still waiting out `DONE_SETTLE_MS`: it may yet carry on. */
 function turnSettling(sessionId) {
 	return pendingDone.has(sessionId);
@@ -8337,6 +8423,24 @@ function setExpecting(ids) {
 		});
 	}
 }
+/** A hook's `permission_mode`: the mode the session is in now (a CLI's
+* own toggle can move it mid-session). */
+function notePermissionMode(sessionId, mode) {
+	modes.set(sessionId, mode);
+}
+function permissionMode(sessionId) {
+	return modes.get(sessionId);
+}
+/** The line its hooks last gave a wait or a turn's end (what a push says). */
+function summaryOf(sessionId) {
+	return summaries.get(sessionId);
+}
+function noteActivity(sessionId, text) {
+	activities.set(sessionId, text);
+}
+function activityOf(sessionId) {
+	return activities.get(sessionId);
+}
 /** Someone typed into the session's pane from a page. */
 function noteTyped(sessionId) {
 	typedAt.set(sessionId, Date.now());
@@ -8424,9 +8528,13 @@ function sessionWatched(sessionId) {
 	return (viewers.get(sessionId) ?? 0) > 0;
 }
 async function notify(sessionId, reason) {
-	const row = get(`SELECT s.agent, s.title, s.workspace_id, w.name FROM sessions s
-     JOIN workspaces w ON w.id = s.workspace_id WHERE s.id = ?`, sessionId);
+	const row = get(`SELECT s.agent, s.title, s.workspace_id, w.name,
+            p.agent AS parent_agent, p.title AS parent_title
+     FROM sessions s JOIN workspaces w ON w.id = s.workspace_id
+     LEFT JOIN sessions p ON p.id = s.parent_id WHERE s.id = ?`, sessionId);
 	if (!row) return;
+	const parent = row.parent_agent ? `${row.parent_title || agentLabel(row.parent_agent)} › ` : "";
+	if (parent && reason === "done") return;
 	if ((viewers.get(sessionId) ?? 0) > 0) return;
 	if (!notifyOn(reason)) return;
 	const waiting = [.../* @__PURE__ */ new Set([...phases.keys(), ...scraped.keys()])].filter((id) => agentPhase(id) === "waiting").length;
@@ -8434,7 +8542,7 @@ async function notify(sessionId, reason) {
 	const mark = reason === "done" ? "✔" : "⚠";
 	const inst = getInstance().name;
 	sendPush({
-		title: `${mark} ${inst ? `${inst} · ` : ""}${row.name} · ${row.title || agentLabel(row.agent)}`,
+		title: `${mark} ${inst ? `${inst} · ` : ""}${row.name} · ${parent}${row.title || agentLabel(row.agent)}`,
 		body: summary || (reason === "done" ? "Finished" : "Needs you"),
 		tag: `session-${sessionId}`,
 		badge: waiting,
@@ -8451,6 +8559,8 @@ function clearAgentPhase(sessionId) {
 	summaries.delete(sessionId);
 	lastMessages.delete(sessionId);
 	typedAt.delete(sessionId);
+	modes.delete(sessionId);
+	activities.delete(sessionId);
 	reportedAt.delete(sessionId);
 	interruptedAt.delete(sessionId);
 	if (!phases.has(sessionId) && !scraped.has(sessionId) && !background.has(sessionId)) return;
@@ -8488,12 +8598,53 @@ function publishChange(sessionId) {
 	const row = get("SELECT workspace_id FROM sessions WHERE id = ?", sessionId);
 	if (row?.workspace_id) {
 		const workspaceId = row.workspace_id;
-		import("./_L2HNAA_8.js").then((m) => m.notifySessionsChanged(workspaceId));
+		import("./_DrEeyoLF.js").then((m) => m.notifySessionsChanged(workspaceId));
 		return;
 	}
 	publish("sessions.changed");
 }
 //#endregion
+//#region src/server/paths.ts
+/** Whether `target` is `root` or somewhere under it, by name alone. Both
+* are normalised first, so `..` and a trailing slash count as the
+* filesystem would count them, and the separator after `root` is the
+* whole point: a sibling `…/work-2` is not in `…/work`. A relative
+* `target` is in nothing — an empty one is a process cwd that could not
+* be read, not the root. A symlink under `root` can still lead out: what
+* is read through one wants `realInside`. */
+function inside(target, root) {
+	if (!path.isAbsolute(target)) return false;
+	const top = path.resolve(root);
+	const full = path.resolve(target);
+	return full === top || full.startsWith(top.endsWith(path.sep) ? top : top + path.sep);
+}
+/** Where `file` — named from `root`, as git and the pages name a
+* checkout's files, or absolute — really leads through every symlink,
+* when that is still `root` or under it; null when it leads out or is not
+* there. The check by name alone lets a symlink in a repo, which a branch
+* can add, point a read at any file on the machine. */
+async function realInside(file, root) {
+	const full = path.resolve(root, file);
+	if (!inside(full, root)) return null;
+	try {
+		const [top, real] = await Promise.all([fs$1.realpath(root), fs$1.realpath(full)]);
+		return inside(real, top) ? real : null;
+	} catch {
+		return null;
+	}
+}
+/** `realInside` for a caller that cannot wait. */
+function realInsideSync(file, root) {
+	const full = path.resolve(root, file);
+	if (!inside(full, root)) return null;
+	try {
+		const real = fs.realpathSync(full);
+		return inside(real, fs.realpathSync(root)) ? real : null;
+	} catch {
+		return null;
+	}
+}
+//#endregion
 //#region src/agents/hooks.ts
 /** Shell command a CLI hook runs to report a state: POSTs the hook's own
 * stdin JSON to the app, which mines it for a notification summary. `exit 0`
@@ -9021,6 +9172,15 @@ var QUESTION_TOOL$1 = "AskUserQuestion";
 * wait as the lead's own prompt. Claude's own notification type, beside
 * the shared ones. */
 var WORKER_PERMISSION = "worker_permission_prompt";
+/** The modes `--permission-mode` takes; `default` is no flag at all. */
+var MODES = /* @__PURE__ */ new Set([
+	"acceptEdits",
+	"auto",
+	"bypassPermissions",
+	"manual",
+	"dontAsk",
+	"plan"
+]);
 /** How StopFailure's `error` reads on a phone. */
 var FAILURES = {
 	authentication_failed: "Signed out",
@@ -9165,10 +9325,14 @@ var claude = {
 		]
 	]) })],
 	reportsWorking: () => true,
+	modeFlags: (mode) => MODES.has(mode) ? ["--permission-mode", mode] : [],
 	envPrefixes: ["CLAUDE", "AI_AGENT"],
 	startupQuestions: [{
 		screen: /Is this a project you created or one you trust/,
 		asks: "whether to trust this folder"
+	}, {
+		screen: /running in Bypass Permissions mode[\s\S]*Yes, I accept/,
+		asks: "whether to accept Bypass Permissions mode"
 	}],
 	readHook: readHook$6,
 	usage: () => Promise.all(claudeAccounts().map((account) => claudeRow(account)))
@@ -9806,47 +9970,6 @@ var cursor = {
 	usage: () => cursorRow().then((row) => [row])
 };
 //#endregion
-//#region src/server/paths.ts
-/** Whether `target` is `root` or somewhere under it, by name alone. Both
-* are normalised first, so `..` and a trailing slash count as the
-* filesystem would count them, and the separator after `root` is the
-* whole point: a sibling `…/work-2` is not in `…/work`. A relative
-* `target` is in nothing — an empty one is a process cwd that could not
-* be read, not the root. A symlink under `root` can still lead out: what
-* is read through one wants `realInside`. */
-function inside(target, root) {
-	if (!path.isAbsolute(target)) return false;
-	const top = path.resolve(root);
-	const full = path.resolve(target);
-	return full === top || full.startsWith(top.endsWith(path.sep) ? top : top + path.sep);
-}
-/** Where `file` — named from `root`, as git and the pages name a
-* checkout's files, or absolute — really leads through every symlink,
-* when that is still `root` or under it; null when it leads out or is not
-* there. The check by name alone lets a symlink in a repo, which a branch
-* can add, point a read at any file on the machine. */
-async function realInside(file, root) {
-	const full = path.resolve(root, file);
-	if (!inside(full, root)) return null;
-	try {
-		const [top, real] = await Promise.all([fs$1.realpath(root), fs$1.realpath(full)]);
-		return inside(real, top) ? real : null;
-	} catch {
-		return null;
-	}
-}
-/** `realInside` for a caller that cannot wait. */
-function realInsideSync(file, root) {
-	const full = path.resolve(root, file);
-	if (!inside(full, root)) return null;
-	try {
-		const real = fs.realpathSync(full);
-		return inside(real, fs.realpathSync(root)) ? real : null;
-	} catch {
-		return null;
-	}
-}
-//#endregion
 //#region src/agents/grok/usage.ts
 var AUTH = path.join(HOME, ".grok", "auth.json");
 var LOG = path.join(HOME, ".grok", "logs", "unified.jsonl");
@@ -10441,6 +10564,10 @@ function agentFor(id) {
 function agentLaunchFlags(id, ctx) {
 	return agentFor(id)?.launchFlags?.(ctx) ?? [];
 }
+/** Argv that starts an instance in a permission mode (`modeFlags`). */
+function agentModeFlags(id, mode) {
+	return mode ? agentFor(id)?.modeFlags?.(mode) ?? [] : [];
+}
 /** Env for a spawned pane so the agent CLI reports state — the families
 * configured by environment rather than argv. */
 function agentLaunchEnv(id, ctx) {
@@ -10496,15 +10623,17 @@ function getSession(id) {
 * workspace at once (restored tabs, a phone and a desktop) both list no
 * sessions before either POST lands. The check and the insert run in one
 * synchronous step, so the second gets the first one's session. */
-function createSession(workspaceId, agent, ifEmpty = false, parent) {
+function createSession(workspaceId, agent, ifEmpty = false, start = {}) {
 	if (!isKnownAgent(agent)) throw new Error(`unknown session kind: ${agent}`);
 	if (ifEmpty) {
 		const first = listSessions(workspaceId)[0];
 		if (first) return first;
 	}
-	const parentId = parent && getSession(parent)?.workspace_id === workspaceId ? parent : null;
+	const parent = start.parent ? getSession(start.parent) : void 0;
+	const parentId = parent?.workspace_id === workspaceId ? parent.id : null;
+	const mode = start.launchMode !== void 0 ? start.launchMode : parentId ? permissionMode(parentId) ?? parent?.launch_mode ?? null : null;
 	const id = Math.random().toString(36).slice(2, 10);
-	db.prepare("INSERT INTO sessions (id, workspace_id, agent, parent_id) VALUES (?, ?, ?, ?)").run(id, workspaceId, agent, parentId);
+	db.prepare("INSERT INTO sessions (id, workspace_id, agent, parent_id, launch_dir, launch_mode, keep) VALUES (?, ?, ?, ?, ?, ?, ?)").run(id, workspaceId, agent, parentId, start.launchDir ?? null, mode, start.keep ? 1 : 0);
 	notifySessionsChanged(workspaceId);
 	return getSession(id);
 }
@@ -10514,11 +10643,24 @@ function renameSession(id, title) {
 	db.prepare("UPDATE sessions SET title = ? WHERE id = ?").run(title, id);
 	notifySessionsChanged(session.workspace_id);
 }
-async function killSession(id) {
+/** 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) {
 	const session = getSession(id);
-	if (!session) return;
-	await disposeSession(session.id);
+	if (!session) return [];
+	const family = keepChildren ? [id] : [id, ...descendantsOf(id)];
+	for (const member of family) await disposeSession(member);
 	notifySessionsChanged(session.workspace_id);
+	return family;
+}
+/** Every session `id` started, and theirs, nearest first. */
+function descendantsOf(id) {
+	return all(`WITH RECURSIVE kids(id, depth) AS (
+       SELECT id, 1 FROM sessions WHERE parent_id = ?
+       UNION SELECT s.id, k.depth + 1 FROM sessions s JOIN kids k ON s.parent_id = k.id
+     )
+     SELECT id FROM kids GROUP BY id ORDER BY MIN(depth)`, id).map((r) => r.id);
 }
 /** Drop tmux + DB row with no sessions.changed — used when the workspace
 * is already gone from the list (delete notifies workspaces first). */
@@ -10607,12 +10749,14 @@ function notifySessionsChanged(workspaceId) {
 async function emitSessionsChanged(workspaceId) {
 	try {
 		const states = await sessionStates();
+		const { teamsOf } = await import("./_E0fWorAK.js");
 		publish("sessions.changed", {
 			workspaceId,
 			sessions: listSessions(workspaceId).map((s) => ({
 				...s,
 				state: states[s.id] || { alive: false }
-			}))
+			})),
+			teams: await teamsOf(workspaceId)
 		});
 	} catch {
 		publish("sessions.changed", { workspaceId });
@@ -10901,18 +11045,34 @@ function newSessionArgs(session, wsPath, mode, initialPrompt, size) {
 		"-s",
 		tmuxName(session.id),
 		"-c",
-		wsPath,
+		launchDir(session, wsPath),
 		...sessionEnvArgs(session, wsPath),
-		...loginShellCommand(session.agent, wsPath, initialPrompt)
+		...loginShellCommand(session, launchDir(session, wsPath), initialPrompt)
 	];
 }
+/** Where a session's process starts: its `launch_dir` when that is still
+* a folder inside its workspace (a topic's worktree, which `topic done`
+* removes), else the workspace itself. */
+function launchDir(session, wsPath) {
+	if (!session.launch_dir) return wsPath;
+	const dir = realInsideSync(session.launch_dir, wsPath);
+	try {
+		if (dir && fs.statSync(dir).isDirectory()) return dir;
+	} catch {}
+	return wsPath;
+}
 /** Run the agent through a login shell so the pane's PATH matches the
 * user's interactive terminal (mise activation, cargo, custom bins) —
 * a service manager's PATH is far slimmer than a login shell's. */
-function loginShellCommand(agent, cwd, initialPrompt) {
+function loginShellCommand(session, cwd, initialPrompt) {
+	const agent = session.agent;
 	const words = sessionCommand(agent);
 	if (!words.length) return [];
-	const line = [...words, ...agentLaunchFlags(agent, { cwd })].map(shellQuote);
+	const line = [
+		...words,
+		...agentLaunchFlags(agent, { cwd }),
+		...agentModeFlags(agent, session.launch_mode)
+	].map(shellQuote);
 	if (initialPrompt) {
 		const file = shellQuote(initialPrompt.file);
 		if (initialPrompt.text.startsWith("-")) line.push("--");
@@ -11050,4 +11210,4 @@ function sleep(ms) {
 	return new Promise((resolve) => setTimeout(resolve, ms));
 }
 //#endregion
-export { agentBadge as $, FRAME_ANCESTORS as $t, realInsideSync as A, doctor as At, noteTyped as B, enableUntrackedCache as Bt, tmuxName as C, enabledAgents as Ct, reportsWorking as D, setPref as Dt, readHookPayload as E, setDisabledAgents as Et, hookReportedAt as F, stableGh as Ft, sessionWatched as G, PROJECT_TOOLS as Gt, notifyEventOn as H, untrackedCacheAllowed as Ht, interruptedSinceReport as I, tilde as It, setScrapedPhase as J, agentLabel$1 as Jt, setAgentPhase as K, TOOLS as Kt, lastTypedAt as L, which as Lt, agentPhase as M, miseInstalls as Mt, clearAgentPhase as N, miseVersions as Nt, inside as O, setSetting as Ot, hookPhase as P, setupPath as Pt, turnSettling as Q, applyPrefChange as Qt, noteBackground as R, hostReach as Rt, sessionStates as S, disabledAgents as St, AGENTS as T, preferredAgent as Tt, onPhaseChange as U, firewallProbe as Ut, noteUserAnswered as V, unsetCaches as Vt, onTurnEnd as W, DEFAULT_GITHUB_HOST as Wt, settleQuietWorking as X, parseAgentId as Xt, setSessionViewers as Y, catalogPin as Yt, turnPhase as Z, toolById as Zt, notifySessionsChanged as _, tmux as _n, agentChoices as _t, creationOf as a, publishJson as an, getInstance as at, renameSession as b, swr as bn, deleteSetting as bt, forgetPanes as c, all as cn, normalizeAccent as ct, killWorkspaceSessions as d, workspacePath as dn, pushPublicKey as dt, FRAME_HEADERS as en, agentFamily as et, listPanes as f, TMUX_SOCKET as fn, saveSubscription as ft, newSessionArgs as g, run$2 as gn, WORKSPACE_PREFS as gt, markTmuxStarted as h, gitEnv as hn, PREF_MAX as ht, createSession as i, publish as in, ACCENT_RE as it, blankRow as j, ghKnownHosts as jt, realInside as k, discoverAgents as kt, getSession as l, db as ln, setInstance as lt, listSessions as m, git as mn, validSubscription as mt, cleanEnv as n, httpError as nn, agentLabel as nt, disposeSessions as o, subscribe as on, iconSvg as ot, listPanesWithin as p, gh as pn, sendPush as pt, setExpecting as q, agentById as qt, clearTmuxStarted as r, readBody as rn, agentMeta as rt, ensureTmuxServer as s, subscriberCount as sn, manifest as st, beginCreation as t, checked as tn, agentFromCommand as tt, killSession as u, get as un, deleteSubscription as ut, onSessionDispose as v, config as vn, allPrefs as vt, tmuxWasStarted as w, getSetting as wt, sendToSession as x, withLock as xn, deleteWorkspacePrefs as xt, panePids as y, shared as yn, changePref as yt, noteInterrupt as z, unreachableText as zt };
+export { setAgentPhase as $, DEFAULT_GITHUB_HOST as $t, blankRow as A, withLock as An, disabledAgents as At, interruptedSinceReport as B, ghKnownHosts as Bt, sendToSession as C, git as Cn, PREF_MAX as Ct, AGENTS as D, config as Dn, changePref as Dt, tmuxWasStarted as E, tmux as En, allPrefs as Et, activityOf as F, setDisabledAgents as Ft, notePermissionMode as G, tilde as Gt, noteActivity as H, miseVersions as Ht, agentPhase as I, setPref as It, notifyEventOn as J, unreachableText as Jt, noteTyped as K, which as Kt, clearAgentPhase as L, setSetting as Lt, inside as M, getSetting as Mt, realInside as N, isKnownAgent as Nt, readHookPayload as O, shared as On, deleteSetting as Ot, realInsideSync as P, preferredAgent as Pt, sessionWatched as Q, firewallProbe as Qt, hookPhase as R, discoverAgents as Rt, renameSession as S, gh as Sn, validSubscription as St, tmuxName as T, run$2 as Tn, agentChoices as Tt, noteBackground as U, setupPath as Ut, lastTypedAt as V, miseInstalls as Vt, noteInterrupt as W, stableGh as Wt, onPhaseChange as X, unsetCaches as Xt, onFinished as Y, enableUntrackedCache as Yt, onTurnEnd as Z, untrackedCacheAllowed as Zt, markTmuxStarted as _, all as _n, setInstance as _t, creationOf as a, parseAgentId as an, turnPhase as at, onSessionDispose as b, workspacePath as bn, saveSubscription as bt, ensureTmuxServer as c, FRAME_ANCESTORS as cn, agentFamily as ct, killSession as d, httpError as dn, agentMeta as dt, PROJECT_TOOLS as en, setExpecting as et, killWorkspaceSessions as f, readBody as fn, ACCENT_RE as ft, listSessions as g, subscriberCount as gn, normalizeAccent as gt, listPanesWithin as h, subscribe as hn, manifest as ht, createSession as i, catalogPin as in, summaryOf as it, cleanSummary as j, enabledAgents as jt, reportsWorking as k, swr as kn, deleteWorkspacePrefs as kt, forgetPanes as l, FRAME_HEADERS as ln, agentFromCommand as lt, listPanes as m, publishJson as mn, iconSvg as mt, cleanEnv as n, agentById as nn, setSessionViewers as nt, descendantsOf as o, toolById as on, turnSettling as ot, launchDir as p, publish as pn, getInstance as pt, noteUserAnswered as q, hostReach as qt, clearTmuxStarted as r, agentLabel$1 as rn, settleQuietWorking as rt, disposeSessions as s, applyPrefChange as sn, agentBadge as st, beginCreation as t, TOOLS as tn, setScrapedPhase as tt, getSession as u, checked as un, agentLabel as ut, newSessionArgs as v, db as vn, deleteSubscription as vt, sessionStates as w, gitEnv as wn, WORKSPACE_PREFS as wt, panePids as x, TMUX_SOCKET as xn, sendPush as xt, notifySessionsChanged as y, get as yn, pushPublicKey as yt, hookReportedAt as z, doctor as zt };