@prometheus-ai/agent 0.5.3 → 0.5.8

package/src/modes/rpc/rpc-subagents.ts

@@ -0,0 +1,265 @@
+import * as fs from "node:fs/promises";
+import { isEnoent } from "@prometheus-ai/utils";
+import type { FileEntry, SessionMessageEntry } from "../../session/session-entries";
+import { parseSessionEntries } from "../../session/session-loader";
+import {
+	type AgentProgress,
+	type SubagentEventPayload,
+	type SubagentLifecyclePayload,
+	type SubagentProgressPayload,
+	TASK_SUBAGENT_EVENT_CHANNEL,
+	TASK_SUBAGENT_LIFECYCLE_CHANNEL,
+	TASK_SUBAGENT_PROGRESS_CHANNEL,
+} from "../../task";
+import type { EventBus } from "../../utils/event-bus";
+import type {
+	RpcSubagentEventFrame,
+	RpcSubagentFrame,
+	RpcSubagentMessagesResult,
+	RpcSubagentSnapshot,
+	RpcSubagentSubscriptionLevel,
+} from "./rpc-types";
+
+export interface RpcSubagentTranscriptSelector {
+	subagentId?: string;
+	sessionFile?: string;
+	fromByte?: number;
+}
+
+type RpcSubagentOutput = (frame: RpcSubagentFrame) => void;
+
+const MAX_RETAINED_TRANSCRIPT_REFERENCES = 256;
+
+function isSessionMessageEntry(entry: FileEntry): entry is SessionMessageEntry {
+	return entry.type === "message";
+}
+
+function statusFromLifecycle(status: SubagentLifecyclePayload["status"]): AgentProgress["status"] {
+	return status === "started" ? "running" : status;
+}
+
+function isTerminalLifecycleStatus(status: SubagentLifecyclePayload["status"]): boolean {
+	return status !== "started";
+}
+
+function hasSameOwner(
+	payload: Pick<SubagentLifecyclePayload | SubagentProgressPayload, "parentToolCallId" | "sessionFile">,
+	snapshot: RpcSubagentSnapshot,
+): boolean {
+	if (payload.parentToolCallId !== undefined && snapshot.parentToolCallId !== undefined) {
+		return payload.parentToolCallId === snapshot.parentToolCallId;
+	}
+	if (payload.sessionFile !== undefined && snapshot.sessionFile !== undefined) {
+		return payload.sessionFile === snapshot.sessionFile;
+	}
+	return true;
+}
+
+function addPruned(set: Set<string>, value: string, maxSize: number): void {
+	set.delete(value);
+	set.add(value);
+	while (set.size > maxSize) {
+		const oldest = set.keys().next();
+		if (oldest.done) break;
+		set.delete(oldest.value);
+	}
+}
+
+export async function readRpcSubagentTranscript(sessionFile: string, fromByte = 0): Promise<RpcSubagentMessagesResult> {
+	let startByte = Number.isFinite(fromByte) ? Math.max(0, Math.trunc(fromByte)) : 0;
+	const file = Bun.file(sessionFile);
+	let size: number;
+	try {
+		({ size } = await fs.stat(sessionFile));
+	} catch (err) {
+		if (!isEnoent(err)) throw err;
+		return {
+			sessionFile,
+			fromByte: startByte,
+			nextByte: startByte,
+			reset: false,
+			entries: [],
+			messages: [],
+		};
+	}
+	let reset = false;
+	if (startByte > size) {
+		startByte = 0;
+		reset = true;
+	}
+
+	const text = startByte >= size ? "" : await file.slice(startByte).text();
+	const lastNewline = text.lastIndexOf("\n");
+	const completeText = lastNewline >= 0 ? text.slice(0, lastNewline + 1) : "";
+	const entries = completeText.length > 0 ? parseSessionEntries(completeText) : [];
+	const nextByte = startByte + Buffer.byteLength(completeText, "utf8");
+
+	return {
+		sessionFile,
+		fromByte: startByte,
+		nextByte,
+		reset,
+		entries,
+		messages: entries.filter(isSessionMessageEntry).map(entry => entry.message),
+	};
+}
+
+export class RpcSubagentRegistry {
+	#subagents = new Map<string, RpcSubagentSnapshot>();
+	#transcriptSessionFilesBySubagentId = new Map<string, string>();
+	#staleSubagentIds = new Set<string>();
+	#unsubscribers: Array<() => void> = [];
+	#output: RpcSubagentOutput;
+	#subscriptionLevel: RpcSubagentSubscriptionLevel = "off";
+
+	constructor(eventBus: EventBus, output: RpcSubagentOutput) {
+		this.#output = output;
+		this.#unsubscribers.push(
+			eventBus.on(TASK_SUBAGENT_LIFECYCLE_CHANNEL, data => {
+				this.handleLifecycle(data as SubagentLifecyclePayload);
+			}),
+			eventBus.on(TASK_SUBAGENT_PROGRESS_CHANNEL, data => {
+				this.handleProgress(data as SubagentProgressPayload);
+			}),
+			eventBus.on(TASK_SUBAGENT_EVENT_CHANNEL, data => {
+				this.handleEvent(data as SubagentEventPayload);
+			}),
+		);
+	}
+
+	dispose(): void {
+		for (const unsubscribe of this.#unsubscribers) unsubscribe();
+		this.#unsubscribers = [];
+		this.#subagents.clear();
+		this.#transcriptSessionFilesBySubagentId.clear();
+		this.#staleSubagentIds.clear();
+	}
+
+	clear(): void {
+		for (const subagentId of this.#subagents.keys()) {
+			addPruned(this.#staleSubagentIds, subagentId, MAX_RETAINED_TRANSCRIPT_REFERENCES);
+		}
+		for (const subagentId of this.#transcriptSessionFilesBySubagentId.keys()) {
+			addPruned(this.#staleSubagentIds, subagentId, MAX_RETAINED_TRANSCRIPT_REFERENCES);
+		}
+		this.#subagents.clear();
+		this.#transcriptSessionFilesBySubagentId.clear();
+	}
+
+	setSubscriptionLevel(level: RpcSubagentSubscriptionLevel): void {
+		this.#subscriptionLevel = level;
+	}
+
+	getSubscriptionLevel(): RpcSubagentSubscriptionLevel {
+		return this.#subscriptionLevel;
+	}
+
+	getSubagents(): RpcSubagentSnapshot[] {
+		return [...this.#subagents.values()].sort((a, b) => a.index - b.index || a.id.localeCompare(b.id));
+	}
+
+	#rememberTranscriptSession(subagentId: string, sessionFile: string | undefined): void {
+		if (!sessionFile) return;
+		this.#transcriptSessionFilesBySubagentId.delete(subagentId);
+		this.#transcriptSessionFilesBySubagentId.set(subagentId, sessionFile);
+		while (this.#transcriptSessionFilesBySubagentId.size > MAX_RETAINED_TRANSCRIPT_REFERENCES) {
+			const oldest = this.#transcriptSessionFilesBySubagentId.keys().next();
+			if (oldest.done) break;
+			this.#transcriptSessionFilesBySubagentId.delete(oldest.value);
+		}
+	}
+
+	#hasTranscriptSessionFile(sessionFile: string): boolean {
+		for (const snapshot of this.#subagents.values()) {
+			if (snapshot.sessionFile === sessionFile) return true;
+		}
+		for (const transcriptSessionFile of this.#transcriptSessionFilesBySubagentId.values()) {
+			if (transcriptSessionFile === sessionFile) return true;
+		}
+		return false;
+	}
+
+	handleLifecycle(payload: SubagentLifecyclePayload): void {
+		const existing = this.#subagents.get(payload.id);
+		if (existing && !hasSameOwner(payload, existing)) return;
+		if (!existing && payload.status !== "started") return;
+		if (payload.status === "started") {
+			this.#staleSubagentIds.delete(payload.id);
+		}
+		const sessionFile = payload.sessionFile ?? existing?.sessionFile;
+		const snapshot: RpcSubagentSnapshot = {
+			id: payload.id,
+			index: payload.index,
+			agent: payload.agent,
+			agentSource: payload.agentSource,
+			description: payload.description ?? existing?.description,
+			status: statusFromLifecycle(payload.status),
+			task: existing?.task,
+			assignment: existing?.assignment,
+			sessionFile,
+			parentToolCallId: payload.parentToolCallId ?? existing?.parentToolCallId,
+			lastUpdate: Date.now(),
+			progress: existing?.progress,
+		};
+		this.#rememberTranscriptSession(payload.id, sessionFile);
+		if (isTerminalLifecycleStatus(payload.status)) {
+			this.#subagents.delete(payload.id);
+		} else {
+			this.#subagents.set(payload.id, snapshot);
+		}
+		if (this.#subscriptionLevel !== "off") {
+			this.#output({ type: "subagent_lifecycle", payload });
+		}
+	}
+
+	handleProgress(payload: SubagentProgressPayload): void {
+		const progress = payload.progress;
+		if (this.#staleSubagentIds.has(progress.id)) return;
+		const existing = this.#subagents.get(progress.id);
+		if (!existing) return;
+		if (!hasSameOwner(payload, existing)) return;
+		const sessionFile = payload.sessionFile ?? existing?.sessionFile;
+		this.#rememberTranscriptSession(progress.id, sessionFile);
+		this.#subagents.set(progress.id, {
+			id: progress.id,
+			index: payload.index,
+			agent: payload.agent,
+			agentSource: payload.agentSource,
+			description: progress.description ?? existing?.description,
+			status: progress.status,
+			task: payload.task,
+			assignment: payload.assignment,
+			sessionFile,
+			lastUpdate: Date.now(),
+			parentToolCallId: payload.parentToolCallId ?? existing?.parentToolCallId,
+			progress,
+		});
+		if (this.#subscriptionLevel !== "off") {
+			this.#output({ type: "subagent_progress", payload });
+		}
+	}
+
+	handleEvent(payload: SubagentEventPayload): void {
+		if (this.#staleSubagentIds.has(payload.id)) return;
+		if (this.#subscriptionLevel !== "events") return;
+		this.#output({ type: "subagent_event", payload } satisfies RpcSubagentEventFrame);
+	}
+
+	resolveSessionFile(selector: RpcSubagentTranscriptSelector): string {
+		if (selector.subagentId) {
+			const snapshot = this.#subagents.get(selector.subagentId);
+			const sessionFile = snapshot?.sessionFile ?? this.#transcriptSessionFilesBySubagentId.get(selector.subagentId);
+			if (!sessionFile) {
+				throw new Error(`Unknown subagent or session file unavailable: ${selector.subagentId}`);
+			}
+			return sessionFile;
+		}
+
+		if (selector.sessionFile) {
+			if (this.#hasTranscriptSessionFile(selector.sessionFile)) return selector.sessionFile;
+			throw new Error("Unknown subagent session file");
+		}
+
+		throw new Error("get_subagent_messages requires subagentId or sessionFile");
+	}
+}

package/src/modes/rpc/rpc-types.ts

@@ -9,7 +9,15 @@ import type { CompactionResult } from "@prometheus-ai/agent-core/compaction";
 import type { Effort, ImageContent, Model } from "@prometheus-ai/ai";
 import type { BashResult } from "../../exec/bash-executor";
 import type { ContextUsage } from "../../extensibility/extensions/types";
-import type { SessionStats } from "../../session/agent-session";
+import type { AgentSessionEvent, SessionStats } from "../../session/agent-session";
+import type { FileEntry } from "../../session/session-entries";
+import type { AvailableSlashCommandSource } from "../../slash-commands/available-commands";
+import type {
+	AgentProgress,
+	SubagentEventPayload,
+	SubagentLifecyclePayload,
+	SubagentProgressPayload,
+} from "../../task";
 import type { TodoPhase } from "../../tools/todo";
 
 // ============================================================================
@@ -27,9 +35,13 @@ export type RpcCommand =
 
 	// State
 	| { id?: string; type: "get_state" }
+	| { id?: string; type: "get_available_commands" }
 	| { id?: string; type: "set_todos"; phases: TodoPhase[] }
 	| { id?: string; type: "set_host_tools"; tools: RpcHostToolDefinition[] }
 	| { id?: string; type: "set_host_uri_schemes"; schemes: RpcHostUriSchemeDefinition[] }
+	| { id?: string; type: "set_subagent_subscription"; level: RpcSubagentSubscriptionLevel }
+	| { id?: string; type: "get_subagents" }
+	| { id?: string; type: "get_subagent_messages"; subagentId?: string; sessionFile?: string; fromByte?: number }
 
 	// Model
 	| { id?: string; type: "set_model"; provider: string; modelId: string }
@@ -100,10 +112,56 @@ export interface RpcSessionState {
 	contextUsage?: ContextUsage;
 }
 
+export interface RpcAvailableSlashCommand {
+	name: string;
+	aliases?: string[];
+	description?: string;
+	input?: { hint?: string };
+	subcommands?: Array<{ name: string; description?: string; usage?: string }>;
+	source: AvailableSlashCommandSource;
+}
+
+export interface RpcAvailableCommandsUpdateFrame {
+	type: "available_commands_update";
+	commands: RpcAvailableSlashCommand[];
+}
+
+export interface RpcPromptResultFrame {
+	type: "prompt_result";
+	id?: string;
+	agentInvoked: boolean;
+}
+
 export interface RpcHandoffResult {
 	savedPath?: string;
 }
 
+export type RpcSubagentSubscriptionLevel = "off" | "progress" | "events";
+
+export interface RpcSubagentSnapshot {
+	id: string;
+	index: number;
+	agent: string;
+	agentSource: AgentProgress["agentSource"];
+	description?: string;
+	status: AgentProgress["status"];
+	task?: string;
+	assignment?: string;
+	sessionFile?: string;
+	lastUpdate: number;
+	progress?: AgentProgress;
+	parentToolCallId?: string;
+}
+
+export interface RpcSubagentMessagesResult {
+	sessionFile: string;
+	fromByte: number;
+	nextByte: number;
+	reset: boolean;
+	entries: FileEntry[];
+	messages: AgentMessage[];
+}
+
 // ============================================================================
 // RPC Responses (stdout)
 // ============================================================================
@@ -111,7 +169,7 @@ export interface RpcHandoffResult {
 // Success responses with data
 export type RpcResponse =
 	// Prompting (async - events follow)
-	| { id?: string; type: "response"; command: "prompt"; success: true }
+	| { id?: string; type: "response"; command: "prompt"; success: true; data?: { agentInvoked: boolean } }
 	| { id?: string; type: "response"; command: "steer"; success: true }
 	| { id?: string; type: "response"; command: "follow_up"; success: true }
 	| { id?: string; type: "response"; command: "abort"; success: true }
@@ -120,9 +178,37 @@ export type RpcResponse =
 
 	// State
 	| { id?: string; type: "response"; command: "get_state"; success: true; data: RpcSessionState }
+	| {
+			id?: string;
+			type: "response";
+			command: "get_available_commands";
+			success: true;
+			data: { commands: RpcAvailableSlashCommand[] };
+	  }
 	| { id?: string; type: "response"; command: "set_todos"; success: true; data: { todoPhases: TodoPhase[] } }
 	| { id?: string; type: "response"; command: "set_host_tools"; success: true; data: { toolNames: string[] } }
 	| { id?: string; type: "response"; command: "set_host_uri_schemes"; success: true; data: { schemes: string[] } }
+	| {
+			id?: string;
+			type: "response";
+			command: "set_subagent_subscription";
+			success: true;
+			data: { level: RpcSubagentSubscriptionLevel };
+	  }
+	| {
+			id?: string;
+			type: "response";
+			command: "get_subagents";
+			success: true;
+			data: { subagents: RpcSubagentSnapshot[] };
+	  }
+	| {
+			id?: string;
+			type: "response";
+			command: "get_subagent_messages";
+			success: true;
+			data: RpcSubagentMessagesResult;
+	  }
 
 	// Model
 	| {
@@ -212,6 +298,29 @@ export type RpcResponse =
 	// Error response (any command can fail)
 	| { id?: string; type: "response"; command: string; success: false; error: string };
 
+// ============================================================================
+// Subagent Events (stdout)
+// ============================================================================
+
+export interface RpcSubagentLifecycleFrame {
+	type: "subagent_lifecycle";
+	payload: SubagentLifecyclePayload;
+}
+
+export interface RpcSubagentProgressFrame {
+	type: "subagent_progress";
+	payload: SubagentProgressPayload;
+}
+
+export interface RpcSubagentEventFrame {
+	type: "subagent_event";
+	payload: SubagentEventPayload;
+}
+
+export type RpcSubagentFrame = RpcSubagentLifecycleFrame | RpcSubagentProgressFrame | RpcSubagentEventFrame;
+
+export type RpcSessionEventFrame = AgentSessionEvent | RpcSubagentFrame;
+
 // ============================================================================
 // Extension UI Events (stdout)
 // ============================================================================

package/src/modes/runtime-init.ts

@@ -23,6 +23,10 @@ export interface InitializeExtensionsOptions {
 	onShutdown?: () => void;
 	/** Optional UI context (rpc supplies one; print runs headless). */
 	uiContext?: ExtensionUIContext;
+	/** Optional lifecycle hook for extension-originated messages that can start an agent turn. */
+	markAgentInvokingMessage?: () => void;
+	/** Optional lifecycle hook for extension-originated sends whose success/failure determines turn ownership. */
+	trackAgentInvokingMessage?: (task: Promise<unknown>) => void;
 }
 
 /**
@@ -35,19 +39,40 @@ export async function initializeExtensions(session: AgentSession, options: Initi
 	const runner = session.extensionRunner;
 	if (!runner) return;
 
-	const { reportSendError, reportRuntimeError, onShutdown, uiContext } = options;
+	const {
+		reportSendError,
+		reportRuntimeError,
+		onShutdown,
+		uiContext,
+		markAgentInvokingMessage,
+		trackAgentInvokingMessage,
+	} = options;
 	const shutdown = onShutdown ?? (() => {});
 
 	runner.initialize(
 		// ExtensionActions
 		{
 			sendMessage: (message, sendOptions) => {
-				session.sendCustomMessage(message, sendOptions).catch(e => {
+				const sendTask = session.sendCustomMessage(message, sendOptions);
+				if (sendOptions?.triggerTurn) {
+					if (trackAgentInvokingMessage) {
+						trackAgentInvokingMessage(sendTask);
+					} else {
+						markAgentInvokingMessage?.();
+					}
+				}
+				sendTask.catch(e => {
 					reportSendError("extension_send", e instanceof Error ? e : new Error(String(e)));
 				});
 			},
 			sendUserMessage: (content, sendOptions) => {
-				session.sendUserMessage(content, sendOptions).catch(e => {
+				const sendTask = session.sendUserMessage(content, sendOptions);
+				if (trackAgentInvokingMessage) {
+					trackAgentInvokingMessage(sendTask);
+				} else {
+					markAgentInvokingMessage?.();
+				}
+				sendTask.catch(e => {
 					reportSendError("extension_send_user", e instanceof Error ? e : new Error(String(e)));
 				});
 			},

package/src/modes/session-observer-registry.ts

@@ -10,6 +10,15 @@ export interface ObservableSession {
 	description?: string;
 	status: "active" | "completed" | "failed" | "aborted";
 	sessionFile?: string;
+	parentToolCallId?: string;
+	/**
+	 * Spawn runs as a detached background job (parent turn not blocked on it).
+	 * The anchored subagent HUD only lists detached spawns: sync task spawns
+	 * and eval `agent()` spawns are already rendered live by their own inline
+	 * tool block / eval cell.
+	 */
+	detached?: boolean;
+	index?: number;
 	lastUpdate: number;
 	/** Latest progress snapshot from the subagent executor */
 	progress?: AgentProgress;
@@ -26,6 +35,9 @@ export class SessionObserverRegistry {
 	#sessions = new Map<string, ObservableSession>();
 	#listeners = new Set<() => void>();
 	#eventBusUnsubscribers: Array<() => void> = [];
+	#sortOrderById = new Map<string, number>();
+	#parentSortOrderById = new Map<string, number>();
+	#nextSortOrder = 0;
 
 	/** Add a change listener. Returns unsubscribe function. */
 	onChange(cb: () => void): () => void {
@@ -37,8 +49,34 @@ export class SessionObserverRegistry {
 		for (const cb of this.#listeners) cb();
 	}
 
+	#ensureSortOrder(id: string): number {
+		const existing = this.#sortOrderById.get(id);
+		if (existing !== undefined) return existing;
+		const order = this.#nextSortOrder++;
+		this.#sortOrderById.set(id, order);
+		return order;
+	}
+
+	#ensureParentSortOrder(parentToolCallId: string | undefined, order: number): void {
+		if (!parentToolCallId) return;
+		if (this.#parentSortOrderById.has(parentToolCallId)) return;
+		this.#parentSortOrderById.set(parentToolCallId, order);
+	}
+
+	#getStableOrder(session: ObservableSession): number {
+		return this.#sortOrderById.get(session.id) ?? Number.MAX_SAFE_INTEGER;
+	}
+
+	#getGroupOrder(session: ObservableSession): number {
+		const parentOrder = session.parentToolCallId
+			? this.#parentSortOrderById.get(session.parentToolCallId)
+			: undefined;
+		return parentOrder ?? this.#getStableOrder(session);
+	}
+
 	setMainSession(sessionFile?: string): void {
 		const existing = this.#sessions.get("main");
+		this.#ensureSortOrder("main");
 		this.#sessions.set("main", {
 			id: "main",
 			kind: "main",
@@ -53,9 +91,18 @@ export class SessionObserverRegistry {
 	getSessions(): ObservableSession[] {
 		const sessions = [...this.#sessions.values()];
 		sessions.sort((a, b) => {
-			if (a.kind === "main") return -1;
-			if (b.kind === "main") return 1;
-			return a.lastUpdate - b.lastUpdate;
+			if (a.kind === "main" && b.kind !== "main") return -1;
+			if (b.kind === "main" && a.kind !== "main") return 1;
+			if (a.kind === "main" || b.kind === "main") return 0;
+
+			const groupDiff = this.#getGroupOrder(a) - this.#getGroupOrder(b);
+			if (groupDiff !== 0) return groupDiff;
+
+			const aIndex = a.index ?? Number.MAX_SAFE_INTEGER;
+			const bIndex = b.index ?? Number.MAX_SAFE_INTEGER;
+			if (aIndex !== bIndex) return aIndex - bIndex;
+
+			return this.#getStableOrder(a) - this.#getStableOrder(b);
 		});
 		return sessions;
 	}
@@ -71,6 +118,9 @@ export class SessionObserverRegistry {
 	/** Clear all tracked sessions (e.g. on session switch). Keeps EventBus subscriptions and listeners. */
 	resetSessions(): void {
 		this.#sessions.clear();
+		this.#sortOrderById.clear();
+		this.#parentSortOrderById.clear();
+		this.#nextSortOrder = 0;
 		this.#notifyListeners();
 	}
 
@@ -78,6 +128,9 @@ export class SessionObserverRegistry {
 		for (const unsub of this.#eventBusUnsubscribers) unsub();
 		this.#eventBusUnsubscribers = [];
 		this.#sessions.clear();
+		this.#sortOrderById.clear();
+		this.#parentSortOrderById.clear();
+		this.#nextSortOrder = 0;
 		this.#listeners.clear();
 	}
 
@@ -92,10 +145,15 @@ export class SessionObserverRegistry {
 				const status = STATUS_MAP[payload.status];
 				if (!status) return;
 
+				const sortOrder = this.#ensureSortOrder(payload.id);
+				this.#ensureParentSortOrder(payload.parentToolCallId, sortOrder);
 				const existing = this.#sessions.get(payload.id);
 				if (existing) {
 					existing.status = status;
 					existing.lastUpdate = Date.now();
+					existing.index = payload.index;
+					existing.parentToolCallId = payload.parentToolCallId ?? existing.parentToolCallId;
+					existing.detached = payload.detached ?? existing.detached;
 					if (payload.description) existing.description = payload.description;
 					if (payload.sessionFile) existing.sessionFile = payload.sessionFile;
 				} else {
@@ -107,6 +165,9 @@ export class SessionObserverRegistry {
 						description: payload.description,
 						status,
 						sessionFile: payload.sessionFile,
+						parentToolCallId: payload.parentToolCallId,
+						detached: payload.detached,
+						index: payload.index,
 						lastUpdate: Date.now(),
 					});
 				}
@@ -121,8 +182,13 @@ export class SessionObserverRegistry {
 				const id = progress.id;
 				const existing = this.#sessions.get(id);
 
+				const sortOrder = this.#ensureSortOrder(id);
+				this.#ensureParentSortOrder(payload.parentToolCallId, sortOrder);
 				if (existing) {
 					existing.lastUpdate = Date.now();
+					existing.index = payload.index;
+					existing.parentToolCallId = payload.parentToolCallId ?? existing.parentToolCallId;
+					existing.detached = payload.detached ?? existing.detached;
 					existing.progress = progress;
 					if (progress.description) existing.description = progress.description;
 					if (payload.sessionFile) existing.sessionFile = payload.sessionFile;
@@ -135,6 +201,9 @@ export class SessionObserverRegistry {
 						description: progress.description,
 						status: "active",
 						sessionFile: payload.sessionFile,
+						parentToolCallId: payload.parentToolCallId,
+						detached: payload.detached,
+						index: payload.index,
 						lastUpdate: Date.now(),
 						progress,
 					});

package/src/modes/setup-version.ts

@@ -0,0 +1,11 @@
+/**
+ * Setup version the wizard advances a fresh install to. Bump it whenever a new
+ * setup scene lands (or an existing scene raises its `minVersion`).
+ *
+ * Kept in its own dependency-free module so the cold-launch gate in `main.ts`
+ * can answer "is the stored setup version stale?" without statically importing
+ * the full wizard — every scene (sign-in/OAuth, web search, theme previews) plus
+ * the overlay component and their TUI deps. MUST equal `max(scene.minVersion)`
+ * across `ALL_SCENES`; the `setup-wizard` barrel and test suite guard it.
+ */
+export const CURRENT_SETUP_VERSION = 1;