feat(coding-agent): event-driven supervisor agent roster serving list from one ledger

packages/coding-agent/.changes/eng-5794-agent-roster-ledger.md

@@ -0,0 +1,3 @@
+- Made the daemon supervisor own an event-driven agent roster: workers push roster deltas on session events and `list` is served from the supervisor's ledger with zero worker round-trips. Rows are as fresh as the owning worker's last delta; a silent worker's rows are annotated (recovering, last-heard-from) rather than dropped, and the surfaces that display those annotations ship in the follow-up PR.
+- Tracked admitted subagent runs in the supervisor roster from the moment they are queued (they appear in `list` once their session exists), and kept passivated or evicted agents listed as inactive rows instead of disappearing (client-owned workers stay private: their rows are dropped when the worker goes away).
+- Tracked worker liveness in the supervisor roster: a dead worker's rows are flagged "recovering" the moment its socket closes, and rows of silent workers carry a last-heard-from time. These fields are supervisor-internal here; the roster surfaces that display them ship in the follow-up PR.

packages/coding-agent/src/modes/daemon/agent-roster.ts

@@ -1,3 +1,6 @@
+import { canonicalSessionPath } from "../../core/session-lease.js";
+import type { SessionSummary } from "./daemon-session-list.js";
+
 // One status formula shared by every agent surface; surfaces adapt their inputs and never reimplement it.
 export type AgentRosterStatus = "running" | "idle" | "inactive";
 
@@ -16,3 +19,186 @@ export function classifyAgentStatus(input: AgentStatusInput): AgentRosterStatus
 	if (!input.resident) return "inactive";
 	return input.busy || input.hasActiveHeartbeat ? "running" : "idle";
 }
+
+export function isSessionSummaryBusy(
+	summary: Pick<SessionSummary, "isSessionActive" | "hasRunningRlmChildren">,
+): boolean {
+	return summary.isSessionActive || summary.hasRunningRlmChildren === true;
+}
+
+export function classifySessionRosterStatus(
+	summary: Pick<
+		SessionSummary,
+		"activeSessionId" | "activity" | "isSessionActive" | "hasRunningRlmChildren" | "hasActiveHeartbeat"
+	>,
+	queuedChild = false,
+): AgentRosterStatus {
+	return classifyAgentStatus({
+		resident: !!summary.activeSessionId,
+		queuedChild,
+		busy: summary.activity === "working" || isSessionSummaryBusy(summary),
+		hasActiveHeartbeat: summary.hasActiveHeartbeat === true,
+	});
+}
+
+export type RosterSessionSummary = Omit<SessionSummary, "streamingMessage" | "sessionActions" | "diagnostics">;
+
+export interface WorkerRosterEntry {
+	agentId: string;
+	queuedChild?: true;
+	seededCwd?: true;
+	summary: RosterSessionSummary;
+}
+
+export interface AgentRosterEntry extends WorkerRosterEntry {
+	status: AgentRosterStatus;
+	statusLabel?: "queued" | "recovering" | "failed";
+	lastHeardFromAt?: string;
+	workerId?: string;
+}
+
+// Child ids are only unique per parent (32-bit, mkdir-checked); the parent path qualifies them daemon-wide.
+export function rosterAgentIdForSummary(
+	summary: Pick<
+		SessionSummary,
+		"runtimeKind" | "rlmChildId" | "sessionId" | "parentSessionPath" | "parentActiveSessionId"
+	>,
+): string {
+	if (summary.runtimeKind === "subagent" && summary.rlmChildId) {
+		// No-session parents have no path (and no ledger edge); their live parent id still disambiguates.
+		const parentKey = summary.parentSessionPath
+			? canonicalSessionPath(summary.parentSessionPath)
+			: summary.parentActiveSessionId;
+		return parentKey ? `${parentKey}#${summary.rlmChildId}` : summary.rlmChildId;
+	}
+	return summary.sessionId;
+}
+
+export function workerRosterEntryFromSummary(summary: SessionSummary): WorkerRosterEntry {
+	const { streamingMessage, sessionActions, diagnostics, ...slim } = summary;
+	return { agentId: rosterAgentIdForSummary(summary), summary: slim };
+}
+
+function classifyWorkerRosterEntry(entry: WorkerRosterEntry): AgentRosterStatus {
+	return classifySessionRosterStatus(entry.summary, entry.queuedChild === true);
+}
+
+export function passivatedWorkerRosterEntry(
+	entry: WorkerRosterEntry,
+	registrations?: { hasRegisteredHeartbeat: boolean; hasRegisteredCronJob: boolean },
+): WorkerRosterEntry {
+	const {
+		activeSessionId,
+		hasActiveHeartbeat,
+		hasRegisteredHeartbeat,
+		hasRegisteredCronJob,
+		hasRunningRlmChildren,
+		isBashRunning,
+		isRunningTools,
+		workerState,
+		workerPid,
+		...summary
+	} = entry.summary;
+	return {
+		agentId: entry.agentId,
+		summary: {
+			...summary,
+			id: summary.sessionId,
+			activity: "idle",
+			isSessionActive: false,
+			isStreaming: false,
+			isCompacting: false,
+			attachedClients: 0,
+			...(registrations?.hasRegisteredHeartbeat ? { hasRegisteredHeartbeat: true } : {}),
+			...(registrations?.hasRegisteredCronJob ? { hasRegisteredCronJob: true } : {}),
+		},
+	};
+}
+
+export function sessionSummaryFromRosterEntry(entry: WorkerRosterEntry): SessionSummary {
+	return { ...entry.summary, sessionActions: { queuedCount: 0, steering: [], followUps: [] } };
+}
+
+export class AgentRoster {
+	private readonly entries = new Map<string, AgentRosterEntry>();
+	private readonly agentIdByActiveSessionId = new Map<string, string>();
+	private readonly agentIdBySessionFile = new Map<string, string>();
+
+	constructor(private readonly canonicalPath: (path: string) => string) {}
+
+	values(): IterableIterator<AgentRosterEntry> {
+		return this.entries.values();
+	}
+
+	get(agentId: string): AgentRosterEntry | undefined {
+		return this.entries.get(agentId);
+	}
+
+	has(agentId: string): boolean {
+		return this.entries.has(agentId);
+	}
+
+	byActiveSessionId(activeSessionId: string): AgentRosterEntry | undefined {
+		const agentId = this.agentIdByActiveSessionId.get(activeSessionId);
+		return agentId !== undefined ? this.entries.get(agentId) : undefined;
+	}
+
+	bySessionFile(canonicalPath: string): AgentRosterEntry | undefined {
+		const agentId = this.agentIdBySessionFile.get(canonicalPath);
+		return agentId !== undefined ? this.entries.get(agentId) : undefined;
+	}
+
+	hasSessionFile(canonicalPath: string): boolean {
+		return this.agentIdBySessionFile.has(canonicalPath);
+	}
+
+	entriesForWorker(workerId: string): AgentRosterEntry[] {
+		return [...this.entries.values()].filter((entry) => entry.workerId === workerId);
+	}
+
+	write(entry: WorkerRosterEntry, workerId?: string, statusLabel?: AgentRosterEntry["statusLabel"]): AgentRosterEntry {
+		const stored: AgentRosterEntry = {
+			...entry,
+			status: classifyWorkerRosterEntry(entry),
+			...(entry.queuedChild ? { statusLabel: "queued" as const } : statusLabel ? { statusLabel } : {}),
+			...(workerId !== undefined ? { workerId } : {}),
+		};
+		const previous = this.entries.get(entry.agentId);
+		if (previous) this.dropIndexes(previous);
+		if (stored.summary.sessionFile) {
+			const file = this.canonicalPath(stored.summary.sessionFile);
+			const existingAgentId = this.agentIdBySessionFile.get(file);
+			if (existingAgentId !== undefined && existingAgentId !== entry.agentId) {
+				this.delete(existingAgentId);
+			}
+			this.agentIdBySessionFile.set(file, entry.agentId);
+		}
+		if (stored.summary.activeSessionId) {
+			this.agentIdByActiveSessionId.set(stored.summary.activeSessionId, entry.agentId);
+		}
+		this.entries.set(entry.agentId, stored);
+		return stored;
+	}
+
+	delete(agentId: string): void {
+		const entry = this.entries.get(agentId);
+		if (!entry) return;
+		this.dropIndexes(entry);
+		this.entries.delete(agentId);
+	}
+
+	private dropIndexes(entry: AgentRosterEntry): void {
+		if (
+			entry.summary.activeSessionId &&
+			this.agentIdByActiveSessionId.get(entry.summary.activeSessionId) === entry.agentId
+		) {
+			this.agentIdByActiveSessionId.delete(entry.summary.activeSessionId);
+		}
+		if (entry.summary.sessionFile) {
+			const file = this.canonicalPath(entry.summary.sessionFile);
+			if (this.agentIdBySessionFile.get(file) === entry.agentId) {
+				this.agentIdBySessionFile.delete(file);
+			}
+		}
+	}
+}