pi-straw-boss 0.33.2 → 0.33.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-straw-boss",
-  "version": "0.33.2",
+  "version": "0.33.3",
   "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/dashboard.ts

@@ -4,7 +4,7 @@ import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import { ARROW, headOf, type HerdrRun, type HerdrWorld, isSub, MARK, type Pane, parentOf, type Session, TOWER_LABEL, type Workspace, worldOf } from "./herdr.ts";
 
-// The tower's monitoring screen: a widget above the editor, never focused, redrawn only while something is working.
+// The tower's monitoring screen: a widget above the editor, never focused, animated only while something is working and the tower's tab is on screen.
 //
 // Data sources, all read-only:
 //  - pi-intercom listSessions(): every live session, its status (idle, thinking, tool:<name>), and its Herdr location.
@@ -20,11 +20,11 @@ export type Mark = "working" | "waiting" | "idle" | "done" | "error" | "unknown"
 /** One line of the tree. `net` rows are tab (0) > session (1) > subagent (2); `towers` rows are flat. */
 /** `ended`: a subagent whose run is over (pi-herdr-agents recorded it done, or its pane is gone or back at a shell); its parent has the result. */
 export interface Row { group: "net" | "towers"; depth: number; mark: Mark; text: string; kind?: string; note?: string; workspace?: string; id?: string; file?: string; pane?: string; ended?: boolean; finished?: boolean }
-export interface Snapshot { title: string; mark: Mark; head: boolean; rows: Row[]; gui?: string }
+export interface Snapshot { title: string; mark: Mark; head: boolean; rows: Row[]; gui?: string; visible?: boolean } // visible: the tower's tab is the active tab of the focused workspace (unknown without a tabId)
 export type Tone = "accent" | "warning" | "muted" | "success" | "dim" | "error" | "border" | "title" | "tower" | "main" | "member";
 export type Paint = (tone: Tone, text: string) => string;
 /** `world` reads the panes and workspaces; without it they are listed through `run`. */
-export interface Sources { run: HerdrRun; world?: HerdrWorld; sessions(): Promise<Session[]>; workspaceId: string; now?: number; gui?(): Promise<string | undefined> }
+export interface Sources { run: HerdrRun; world?: HerdrWorld; sessions(): Promise<Session[]>; workspaceId: string; tabId?: string; now?: number; gui?(): Promise<string | undefined> }
 
 const KEY = "straw-boss-dashboard";
 const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
@@ -187,7 +187,7 @@ export function subagents(parent: Pane | undefined, all: Pane[], now: number, li
  * One reading of the world as rows: this tower's own net in detail (each tab's joined sessions with their subagents, then its
  * sub workspaces), and one summary line for every other tower. Other workspaces' sessions, and sessions that did not join, are not listed.
  */
-export async function collect({ run, world = worldOf(run), sessions, workspaceId, now = Date.now(), gui }: Sources): Promise<Snapshot> {
+export async function collect({ run, world = worldOf(run), sessions, workspaceId, tabId, now = Date.now(), gui }: Sources): Promise<Snapshot> {
 	const [live, { panes: ps, workspaces: all }] = await Promise.all([sessions(), world()]);
 	const head = headOf(all);
 	const mine = all.find((w) => w.workspace_id === workspaceId);
@@ -215,7 +215,7 @@ export async function collect({ run, world = worldOf(run), sessions, workspaceId
 	for (const w of all.filter((x) => x !== mine && !isSub(x) && live.some((s) => s.id === x.tokens?.tower))) rows.push({ group: "towers", depth: 0, mark: markOf(w.agent_status), text: w.label, kind: w === head ? "head tower" : "tower" });
 	// The title shows what needs attention most: a waiting row, then a working one, else the workspace's own status.
 	const attention = (["waiting", "working"] as const).find((m) => rows.some((r) => r.mark === m || (m === "working" && r.mark === "commanding"))); // commanding is active, like working
-	return { title: mine?.label ?? workspaceId, mark: attention ?? markOf(mine?.agent_status), head: Boolean(mine) && mine === head, rows, gui: await gui?.().catch(() => undefined) };
+	return { title: mine?.label ?? workspaceId, mark: attention ?? markOf(mine?.agent_status), head: Boolean(mine) && mine === head, rows, gui: await gui?.().catch(() => undefined), visible: tabId === undefined ? undefined : Boolean(mine?.focused) && mine?.active_tab_id === tabId };
 }
 
 export interface Dashboard { poke(): void; stop(): void }
@@ -227,12 +227,12 @@ export const SAFETY_MS = 30_000;
 const DEBOUNCE_MS = 500;
 
 /**
- * Shows the dashboard in a tower's TUI. The spinner timer (8 fps) runs only while a row is working. Data is re-read when `watch` reports
+ * Shows the dashboard in a tower's TUI. The spinner timer (1 fps; each tick redraws the whole TUI) runs only while a row is working and the tower is not `visible: false`. Data is re-read when `watch` reports
  * a change (collected for `debounceMs`, so a burst is one read), when poke() says intercom changed (at once), and every `pollMs` as a safety net;
  * two reads are never closer than `minGapMs`, and a request that comes inside the gap or while a read runs is read when it ends, not dropped.
  * stop() clears the timers and the subscription and removes the widget, and pi disposing the widget does the same.
  */
-export function startDashboard({ ui, collect: read, watch, frameMs = 125, pollMs = SAFETY_MS, minGapMs = 500, debounceMs = DEBOUNCE_MS }: { ui: ExtensionContext["ui"]; collect(): Promise<Snapshot> } & Timing): Dashboard {
+export function startDashboard({ ui, collect: read, watch, frameMs = 1000, pollMs = SAFETY_MS, minGapMs = 500, debounceMs = DEBOUNCE_MS }: { ui: ExtensionContext["ui"]; collect(): Promise<Snapshot> } & Timing): Dashboard {
 	let live: Dashboard | undefined;
 	ui.setWidget(KEY, (tui, theme) => {
 		let snap: Snapshot = { title: "", mark: "unknown", head: false, rows: [] }, frame = 0, busy = false, again = false, stopped = false, last = 0, due = Infinity;
@@ -258,7 +258,7 @@ export function startDashboard({ ui, collect: read, watch, frameMs = 125, pollMs
 			busy = false;
 			last = Date.now();
 			if (stopped) return;
-			const working = snap.mark === "working" || snap.rows.some((r) => r.mark === "working");
+			const working = snap.visible !== false && (snap.mark === "working" || snap.rows.some((r) => r.mark === "working"));
 			if (working && !spinner) spinner = setInterval(() => (frame++, tui.requestRender()), frameMs).unref();
 			if (!working && spinner) spinner = void clearInterval(spinner);
 			tui.requestRender();

package/src/herdr.ts

@@ -19,7 +19,7 @@ export class HerdrError extends Error {
 }
 export type Sleep = (ms: number) => Promise<void>;
 export interface Place { paneId: string; tabId: string; workspaceId: string }
-export interface Workspace { workspace_id: string; label: string; agent_status?: string; tokens?: Record<string, string>; worktree?: { checkout_path?: string; is_linked_worktree?: boolean; repo_key?: string } }
+export interface Workspace { workspace_id: string; label: string; agent_status?: string; focused?: boolean; active_tab_id?: string; tokens?: Record<string, string>; worktree?: { checkout_path?: string; is_linked_worktree?: boolean; repo_key?: string } }
 export interface Pane { pane_id: string; tab_id: string; workspace_id?: string; agent?: string; agent_status?: string; agent_session?: { value: string }; label?: string; cwd?: string; tokens?: Record<string, string> }
 export interface HerdrTab { tab_id: string; workspace_id: string; label?: string }
 export interface Location { status: string; workspace?: { id: string; label: string }; tab?: { id: string; label: string }; paneId?: string }

package/src/tower.ts

@@ -7,8 +7,8 @@ import { ENTRY, type Kit } from "./state.ts";
 import type { Tools } from "./tools.ts";
 
 const SETTLE_MS = 2000;
-// What Herdr reports that changes the dashboard: panes (their agent status and tokens), tabs, and workspaces (their tokens and labels), coming, going, and moving.
-const SCREEN_EVENTS = ["pane.created", "pane.closed", "pane.updated", "pane.moved", "pane.exited", "pane.agent_detected", "tab.created", "tab.closed", "tab.renamed", "tab.moved", "workspace.created", "workspace.updated", "workspace.metadata_updated", "workspace.renamed", "workspace.moved", "workspace.reordered", "workspace.closed"];
+// What Herdr reports that changes the dashboard: panes (their agent status and tokens), tabs, and workspaces (their tokens and labels), coming, going, moving, and taking focus (the spinner runs only on screen).
+const SCREEN_EVENTS = ["pane.created", "pane.closed", "pane.updated", "pane.moved", "pane.exited", "pane.agent_detected", "tab.created", "tab.closed", "tab.renamed", "tab.moved", "tab.focused", "workspace.focused", "workspace.created", "workspace.updated", "workspace.metadata_updated", "workspace.renamed", "workspace.moved", "workspace.reordered", "workspace.closed"];
 
 /** A session that is a tower (`STRAW_BOSS_ROLE=tower`, or marked so in its session) takes the role: its marks, its tools, its dashboard. */
 export function createTower({ pi, cfg, s, guiDir, me }: Kit, { membership, presence, tools }: { membership: Membership; presence: Presence; tools: Tools }) {
@@ -39,6 +39,6 @@ export function createTower({ pi, cfg, s, guiDir, me }: Kit, { membership, prese
 		presence.keepFresh();
 		await presence.publish();
 		// The dashboard lives exactly as long as this session holds the tower role.
-		if (s.hasUI) s.dashboard = startDashboard({ ui: s.ui!, watch: (refresh) => events(SCREEN_EVENTS, () => refresh()), collect: () => collect({ run, world, sessions: () => s.c.listSessions(), workspaceId: s.at.workspaceId, gui: async () => { const r = readRecord(guiDir); return r && (await answers(r)) ? urlOf(r) : undefined; } }) });
+		if (s.hasUI) s.dashboard = startDashboard({ ui: s.ui!, watch: (refresh) => events(SCREEN_EVENTS, () => refresh()), collect: () => collect({ run, world, sessions: () => s.c.listSessions(), workspaceId: s.at.workspaceId, tabId: s.at.tabId, gui: async () => { const r = readRecord(guiDir); return r && (await answers(r)) ? urlOf(r) : undefined; } }) });
 	};
 }