pi-straw-boss 0.9.0 → 0.9.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-straw-boss",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "description": "Straw Boss coordination for pi in Herdr: sessions join a tab's net by choice, the first joiner is its main agent, a workspace tower opens on demand with a live monitoring dashboard, and boss_broadcast reaches the rest",
   "type": "module",
   "license": "MIT",

package/src/herdr.ts

@@ -164,14 +164,24 @@ async function open({ run, sleep, live, moveFirst, model }: TowerEnv, workspace:
 
 	// A leftover tower tab is reused: a pane already running pi only needs its token awaited, a shell prompt gets pi started.
 	// The tab is told apart by the `sb_role=tower` pane token that only Straw Boss writes; a tab merely labelled "tower"
-	// (a pi-herdr-agents subagent can be named so) is someone else's.
+	// (a pi-herdr-agents subagent can be named so) is someone else's. A tab whose token was cleared (its tower quit) is still ours when it has
+	// exactly the tower label (the glyph), one pane, and no agent in it.
 	let paneId: string;
 	let running = false;
-	const marked = (await panes(run, ws)).find((p) => p.tokens?.sb_role === "tower");
-	if (marked) {
-		paneId = marked.pane_id;
-		running = marked.agent === "pi";
-		await moveFirst(marked.tab_id);
+	const here = await panes(run, ws);
+	const marked = here.find((p) => p.tokens?.sb_role === "tower");
+	const bare = marked ? [] : (await tabs(run, ws)).filter((t) => t.label === TOWER_LABEL).flatMap((t) => {
+		const inside = here.filter((p) => p.tab_id === t.tab_id);
+		return inside.length === 1 && !inside[0]!.agent && !inside[0]!.tokens?.sb_role ? [inside[0]!] : [];
+	});
+	const reused = marked ?? bare[0];
+	if (reused) {
+		paneId = reused.pane_id;
+		running = reused.agent === "pi";
+		if (!marked) await report(run, "pane", paneId, { sb_role: "tower" });
+		await moveFirst(reused.tab_id);
+		// Other shell-only leftovers are closed; failing to close one leaves a harmless tab, so it does not stop the tower.
+		for (const extra of bare.slice(1)) await run(["tab", "close", extra.tab_id]).catch(() => {});
 	} else {
 		const dir = workspace.worktree?.checkout_path ?? cwd;
 		const created = await createTab(run, ws, dir, ["STRAW_BOSS_ROLE=tower"], TOWER_LABEL);
@@ -182,7 +192,11 @@ async function open({ run, sleep, live, moveFirst, model }: TowerEnv, workspace:
 	}
 	if (!running) {
 		// Herdr agent names are unique across workspaces and lowercase only, so the name carries the lowercased workspace id.
-		await startPi(run, sleep, `tower-${ws.toLowerCase()}`, paneId, ["--name", `tower · ${workspace.label}`, ...(model ? ["--model", model] : [])]);
+		// An adopted shell that turns out busy (the user runs something there) gives the token back, so the next open does not count it as the tower.
+		await startPi(run, sleep, `tower-${ws.toLowerCase()}`, paneId, ["--name", `tower · ${workspace.label}`, ...(model ? ["--model", model] : [])]).catch(async (error: unknown) => {
+			if (reused && !marked) await report(run, "pane", paneId, { sb_role: null }).catch(() => {});
+			throw error;
+		});
 	}
 	const id = await waitFor(sleep, held, TOWER_WAIT_MS, 1000);
 	if (!id) throw new Error(`The tower of ${workspace.label} did not publish its token within ${TOWER_WAIT_MS / 1000} s (pane ${paneId})`);

package/src/index.ts

@@ -441,7 +441,7 @@ export function createStrawBoss({ run = herdrRun, api = herdrApi(), call = herdr
 			if (["subagent", "subagent_resume"].includes(event.toolName) && !isTower && !barred && role()) for (const ms of KID_MARK_MS) setTimeout(() => void publish(), ms).unref();
 		});
 
-		pi.on("session_shutdown", async () => {
+		pi.on("session_shutdown", async (event) => {
 			if (gui) await switchRemote(gui, false, guiDir, ts).catch(() => {});
 			await gui?.stop();
 			gui = undefined;
@@ -459,6 +459,12 @@ export function createStrawBoss({ run = herdrRun, api = herdrApi(), call = herdr
 			await report(run, "pane", at.paneId, { sb_role: null, sb_opened_by: null, sb_order: null, sb_mark: null, sb_indent: null, sb_tab: null }).catch(() => {});
 			await clearOrder(run, [...kids]);
 			if (held) await report(run, "workspace", at.workspaceId, { tower: null }).catch(() => {});
+			// A tower that quits leaves its tab as a plain shell: close the tab, but only when this pane is all it holds. A reload, /new, resume or fork keeps the tab.
+			if (isTower && event.reason === "quit") {
+				const all = await panes(run, at.workspaceId).catch(() => []);
+				const tab = all.find((p) => p.pane_id === at.paneId)?.tab_id;
+				if (tab && all.every((p) => p.tab_id !== tab || p.pane_id === at.paneId)) await run(["tab", "close", tab]).catch(() => {});
+			}
 		});
 
 		// /boss gui is a read-only viewer: any session may open it, and it joins nothing and writes no token. A session outside the net