@dylanpiercey/work 0.2.18 → 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/{_BlLEM8du.js → _Hb3LeA5Q.js}

@@ -478,6 +478,99 @@ var STEPS = [
 		up(db) {
 			db.exec("DELETE FROM settings WHERE key = 'ui.term-predict'");
 		}
+	},
+	{
+		version: 4,
+		name: "session messages",
+		up(db) {
+			db.exec(`
+        ALTER TABLE sessions ADD COLUMN parent_id TEXT REFERENCES sessions(id) ON DELETE SET NULL;
+
+        CREATE TABLE session_messages (
+          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')),
+          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
+        );
+
+        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;
+      `);
+		}
 	}
 ];
 var LATEST = STEPS.at(-1).version;
@@ -8215,6 +8308,26 @@ var interruptedAt = /* @__PURE__ */ new Map();
 * finished: the session is working until a turn ends with none left, and
 * that end is the one pushed. */
 var background = /* @__PURE__ */ new Map();
+/** Each session's last finished turn's message, whole: what a session
+* that messaged it gets back (server/messages). */
+var lastMessages = /* @__PURE__ */ new Map();
+/** Sessions a message is still to wake (server/messages keeps the set):
+* each asked another something not yet answered, or has one waiting to
+* be typed in. Like background work, that makes the session working, and
+* a turn of it that ends meanwhile has handed off rather than finished. */
+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
 * again each time something sends the agent back to work (a stop hook
 * that continues it, a goal loop, background subagents reporting in), and
@@ -8225,7 +8338,7 @@ var listeners = /* @__PURE__ */ new Set();
 function onPhaseChange(fn) {
 	listeners.add(fn);
 }
-function setAgentPhase(sessionId, phase, reason, summary) {
+function setAgentPhase(sessionId, phase, reason, summary, message) {
 	reportedAt.set(sessionId, Date.now());
 	cancelDone(sessionId);
 	if (phase === "idle") {
@@ -8235,10 +8348,17 @@ function setAgentPhase(sessionId, phase, reason, summary) {
 	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 (!failed && !background.has(sessionId)) pendingDone.set(sessionId, setTimeout(() => {
+		if (!background.has(sessionId)) pendingDone.set(sessionId, setTimeout(() => {
 			pendingDone.delete(sessionId);
-			notify(sessionId, "done");
+			const answered = endTurn(sessionId);
+			if (!failed && !answered && !expecting.has(sessionId)) {
+				for (const fn of finishedListeners) fn(sessionId);
+				notify(sessionId, "done");
+			}
 		}, DONE_SETTLE_MS));
 		return;
 	}
@@ -8273,6 +8393,62 @@ function noteBackground(sessionId, work) {
 		else background.delete(sessionId);
 	});
 }
+/** 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. */
+function onTurnEnd(fn) {
+	turnEndListeners.add(fn);
+}
+function endTurn(sessionId) {
+	let told = false;
+	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);
+}
+/** The sessions a message is still to wake (server/messages). */
+function setExpecting(ids) {
+	for (const id of /* @__PURE__ */ new Set([...expecting, ...ids])) {
+		if (expecting.has(id) === ids.has(id)) continue;
+		applyChange(id, () => {
+			if (ids.has(id)) expecting.add(id);
+			else expecting.delete(id);
+		});
+	}
+}
+/** 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());
+}
+/** When someone last typed into the session's pane (0: not this run). */
+function lastTypedAt(sessionId) {
+	return typedAt.get(sessionId) ?? 0;
+}
 function cancelDone(sessionId) {
 	const timer = pendingDone.get(sessionId);
 	if (!timer) return;
@@ -8352,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;
@@ -8362,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,
@@ -8377,6 +8557,10 @@ async function notify(sessionId, reason) {
 function clearAgentPhase(sessionId) {
 	cancelDone(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;
@@ -8387,11 +8571,17 @@ function clearAgentPhase(sessionId) {
 		background.delete(sessionId);
 	});
 }
-/** What a session is doing. The hook wins where there is one: it reports
-* the turn itself, where tmux only sees the pane still moving after it. */
-function agentPhase(sessionId) {
+/** What a session's own turn is doing. The hook wins where there is one:
+* it reports the turn itself, where tmux only sees the pane still moving
+* after it. Undefined: at its prompt, where a message can be typed in. */
+function turnPhase(sessionId) {
 	return hookPhase(sessionId) ?? scraped.get(sessionId);
 }
+/** What a session is doing: its turn, else working while a message is
+* still to wake it — a session that handed work to another is not done. */
+function agentPhase(sessionId) {
+	return turnPhase(sessionId) ?? (expecting.has(sessionId) ? "working" : void 0);
+}
 /** Apply a mutation and broadcast when it moved the session's phase (or,
 * `force`, its reason: finished and blocked draw differently). Only a
 * hook ever reports "waiting", so a transition into it is a push. */
@@ -8408,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("./_t9VsALwo.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`
@@ -8472,7 +8703,8 @@ function readClaudeStyle(p, reported) {
 	const text = str$1(p.last_assistant_message) || str$1(p["last-assistant-message"]) || str$1(p.lastAssistantMessage);
 	if (text) return {
 		reason,
-		summary: cleanSummary(text)
+		summary: cleanSummary(text),
+		message: text
 	};
 	if (kind) return {
 		reason,
@@ -8940,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",
@@ -9084,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)))
@@ -9503,7 +9748,10 @@ function readHook$4(p, reported, _state) {
 		};
 	}
 	const read = readClaudeStyle(p, reported);
-	if (!read.summary && reported === "done") read.summary = lastMessageFromTranscript(p);
+	if (!read.summary && reported === "done") {
+		read.message = lastMessageFromTranscript(p);
+		if (read.message) read.summary = cleanSummary(read.message);
+	}
 	return read;
 }
 /** The last non-empty `assistant.message` of the turn that just ended in
@@ -9527,7 +9775,7 @@ function lastMessageFromTranscript(p) {
 				try {
 					const ev = JSON.parse(lines[i]);
 					const content = ev.type === "assistant.message" ? ev.data?.content : void 0;
-					if (typeof content === "string" && content.trim()) return cleanSummary(content);
+					if (typeof content === "string" && content.trim()) return content.trim();
 				} catch {}
 			}
 		} finally {
@@ -9722,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");
@@ -10215,7 +10422,8 @@ function readHook$1(p, reported) {
 	const summary = str$1(p.summary);
 	return {
 		reason: reported,
-		summary: summary ? cleanSummary(summary) : void 0
+		summary: summary ? cleanSummary(summary) : void 0,
+		message: summary || void 0
 	};
 }
 var opencode = {
@@ -10323,7 +10531,8 @@ function readHook(p, reported) {
 	const summary = str$1(p.summary);
 	return {
 		reason: reported,
-		summary: summary ? cleanSummary(summary) : void 0
+		summary: summary ? cleanSummary(summary) : void 0,
+		message: summary || void 0
 	};
 }
 //#endregion
@@ -10355,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) {
@@ -10410,14 +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) {
+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 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) VALUES (?, ?, ?)").run(id, workspaceId, agent);
+	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);
 }
@@ -10427,18 +10643,38 @@ 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). */
 async function disposeSessions(sessions) {
 	for (const session of sessions) await disposeSession(session.id);
 }
+/** Told of a session about to go, while its row is still there (its
+* messages go with it: server/messages answers what it owed first). */
+var disposeListeners = /* @__PURE__ */ new Set();
+function onSessionDispose(fn) {
+	disposeListeners.add(fn);
+}
 async function disposeSession(id) {
+	for (const fn of disposeListeners) fn(id);
 	await tmux([
 		"kill-session",
 		"-t",
@@ -10513,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 });
@@ -10807,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("--");
@@ -10956,4 +11210,4 @@ function sleep(ms) {
 	return new Promise((resolve) => setTimeout(resolve, ms));
 }
 //#endregion
-export { iconSvg as $, subscribe as $t, blankRow as A, which as At, onPhaseChange as B, agentById as Bt, tmuxWasStarted as C, doctor as Ct, inside as D, setupPath as Dt, reportsWorking as E, miseVersions as Et, interruptedSinceReport as F, untrackedCacheAllowed as Ft, settleQuietWorking as G, applyPrefChange as Gt, setAgentPhase as H, catalogPin as Ht, noteBackground as I, firewallProbe as It, agentFromCommand as J, checked as Jt, agentBadge as K, FRAME_ANCESTORS as Kt, noteInterrupt as L, DEFAULT_GITHUB_HOST as Lt, clearAgentPhase as M, unreachableText as Mt, hookPhase as N, enableUntrackedCache as Nt, realInside as O, stableGh as Ot, hookReportedAt as P, unsetCaches as Pt, getInstance as Q, publishJson as Qt, noteUserAnswered as R, PROJECT_TOOLS as Rt, tmuxName as S, discoverAgents as St, readHookPayload as T, miseInstalls as Tt, setScrapedPhase as U, parseAgentId as Ut, sessionWatched as V, agentLabel$1 as Vt, setSessionViewers as W, toolById as Wt, agentMeta as X, readBody as Xt, agentLabel as Y, httpError as Yt, ACCENT_RE as Z, publish as Zt, notifySessionsChanged as _, getSetting as _t, creationOf as a, TMUX_SOCKET as an, saveSubscription as at, sendToSession as b, setPref as bt, forgetPanes as c, gitEnv as cn, PREF_MAX as ct, killWorkspaceSessions as d, config as dn, allPrefs as dt, subscriberCount as en, manifest as et, listPanes as f, shared as fn, changePref as ft, newSessionArgs as g, enabledAgents as gt, markTmuxStarted as h, disabledAgents as ht, createSession as i, workspacePath as in, pushPublicKey as it, agentPhase as j, hostReach as jt, realInsideSync as k, tilde as kt, getSession as l, run$2 as ln, WORKSPACE_PREFS as lt, listSessions as m, withLock as mn, deleteWorkspacePrefs as mt, cleanEnv as n, db as nn, setInstance as nt, disposeSessions as o, gh as on, sendPush as ot, listPanesWithin as p, swr as pn, deleteSetting as pt, agentFamily as q, FRAME_HEADERS as qt, clearTmuxStarted as r, get as rn, deleteSubscription as rt, ensureTmuxServer as s, git as sn, validSubscription as st, beginCreation as t, all as tn, normalizeAccent as tt, killSession as u, tmux as un, agentChoices as ut, panePids as v, preferredAgent as vt, AGENTS as w, ghKnownHosts as wt, sessionStates as x, setSetting as xt, renameSession as y, setDisabledAgents as yt, notifyEventOn as z, TOOLS 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 };