scream-code 0.17.7 → 0.17.9

package/dist/{app-BnHwLVy5.mjs → app-DiPC-zEu.mjs}

@@ -4,9 +4,9 @@ import { dirname as __cjsShimDirname } from 'node:path';
 const __filename = __cjsShimFileURLToPath(import.meta.url);
 const __dirname = __cjsShimDirname(__filename);
 import "./suppress-sqlite-warning-C2VB0doZ.mjs";
-import { k as MemoryMemoStore } from "./src-BhZujafw.mjs";
-import { $n as encodeWorkDirKey, $t as lerpGradient, A as highlightLines, An as embeddingFailureDetail, At as isTurnElapsedEnabled, B as ActivityGroupComponent, Bn as detectShellEnvironment, Bt as ENABLE_TERMINAL_THEME_REPORTING, Cn as getLlmNotSetMessage, Ct as clearInfoPanelState, D as ToolCallComponent, Dn as sortSlashCommands, Dt as createEditorTheme, E as UserMessageComponent, En as BUILTIN_SLASH_COMMANDS, Et as resolveThemeSync, F as StatusMessageComponent, Fn as PULSE_WAVE_FRAMES, Ft as detectTerminalTheme, G as AgentGroupComponent, Gn as CLI_COMMAND_NAME, Gt as QUERY_TERMINAL_THEME, H as estimateTokens, Hn as getInputHistoryFile, Ht as OSC11_RESPONSE, I as replaceTabs, In as TuiConfigParseError, It as parseOsc11BackgroundTheme, J as getBreathingFrame, Jn as PRODUCT_NAME, Jt as TERMINAL_THEME_DARK, K as WelcomeComponent, Kn as CLI_UI_MODE, Kt as TERMINAL_FOCUS_IN, L as sanitizeShellOutput, Ln as TuiLikePreferencesSchema, Lt as DISABLE_TERMINAL_FOCUS_REPORTING, M as CachedContainer, Mn as hasEmbeddingModelCache, Mt as createThemeStyles, N as ThinkingComponent, Nn as startManualEmbeddingDownload, Nt as contrastTextHex, O as renderDiffLines, On as isExperimentalFlagEnabled, Ot as createMarkdownTheme, P as NoticeMessageComponent, Pn as PIXEL_PULSE_FRAMES, Pt as getColorPalette, Q as refineGoal, Qn as ScreamHarness, Qt as FooterComponent, R as SkillActivationComponent, Rn as loadTuiConfig, Rt as DISABLE_TERMINAL_THEME_REPORTING, S as readJsonlFile, Sn as getCtrlDHint, St as supportsBalance, Tn as buildSkillSlashCommands, U as getSharedSpeedTracker, Un as getLogDir, Ut as OSC11_RESPONSE_PREFIX, V as charsForTokenBudget, Vn as getDataDir, Vt as OSC11_QUERY, W as BackgroundAgentStatusComponent, Wn as detectInstallSource, Wt as OSC11_RESPONSE_PREFIX_NO_ESC, X as CompactionComponent, Xn as fetchCatalog, Xt as isBusy, Y as resetBreathingClock, Yn as DEFAULT_CATALOG_URL, Yt as TERMINAL_THEME_LIGHT, Z as clearGoalState, Zn as saveCatalogCache, Zt as isStreaming, _n as EXIT_CONFIRM_WINDOW_MS, a as syncDiagramCapabilityPrompt, an as printableChar, ar as isRealUserPrompt, at as toTerminalHyperlink, b as readUpdateCache, bn as TIP_ROTATION_INTERVAL_MS, c as disposeChildren, cn as appendStreamingArgsPreview, cr as log, d as isPlanExpandable, dn as isTodoItemShape, dr as isOrphanedToolCallError, en as SubagentSlots, er as normalizeWorkDir, f as MoonLoader, fn as parseStreamingArgs, fr as ErrorCodes, ft as handleFusionPlanCommand, gn as EMPTY_SESSION_HINT_URL, hn as truncateErrorMessage, i as buildRoleAdditionalText, it as isInternalMessage, j as langFromPath, jn as getKnowledgeStore, jt as toggleEmptySessionHint, k as renderDiffLinesClustered, kn as setExperimentalFlags, kt as isEmptySessionHintDismissed, l as hasDispose, ln as argsRecord, lr as resolveGlobalLogPath, mn as stringValue, mt as handlePlanCommand, n as clearEvalPanelState, nr as readSessionIndex, on as STATUS_BULLET, or as resolveScreamHome, ot as changeThinkingLevel, p as formatMemoryMemoForInjection, pn as serializeToolResultOutput, pr as SCREAM_ERROR_INFO, q as BREATHE_CYCLE_MS, qn as CLI_USER_AGENT_PRODUCT, qt as TERMINAL_FOCUS_OUT, r as openUrl, rr as removeSessionIndexEntry, sn as appendSessionHeaderHint, sr as flushDiagnosticLogs, st as getModelCycleLevel, t as dispatchInput, tr as appendSessionIndexEntry, u as isExpandable, un as formatErrorMessage, ur as isScreamError, v as selectUpdateTarget, vn as MAIN_AGENT_ID, w as getDaemonInstructions, wn as getNoActiveSessionMessage, x as appendJsonlLine, xn as getCtrlCHint, xt as refreshProviderBalance, y as refreshUpdateCache, yn as SESSION_TIPS, z as AssistantMessageComponent, zn as saveTuiConfig, zt as ENABLE_TERMINAL_FOCUS_REPORTING } from "./dispatch-DVZFRvzo.mjs";
-import { a as setLocale, i as getLocale, o as t } from "./text-input-dialog-CD0sakGq.mjs";
+import { A as sharedMemoStore } from "./src-C7C9e5Ds.mjs";
+import { $n as encodeWorkDirKey, $t as lerpGradient, A as highlightLines, An as embeddingFailureDetail, At as isTurnElapsedEnabled, B as ActivityGroupComponent, Bn as detectShellEnvironment, Bt as ENABLE_TERMINAL_THEME_REPORTING, Cn as getLlmNotSetMessage, Ct as clearInfoPanelState, D as ToolCallComponent, Dn as sortSlashCommands, Dt as createEditorTheme, E as UserMessageComponent, En as BUILTIN_SLASH_COMMANDS, Et as resolveThemeSync, F as StatusMessageComponent, Fn as PULSE_WAVE_FRAMES, Ft as detectTerminalTheme, G as AgentGroupComponent, Gn as CLI_COMMAND_NAME, Gt as QUERY_TERMINAL_THEME, H as estimateTokens, Hn as getInputHistoryFile, Ht as OSC11_RESPONSE, I as replaceTabs, In as TuiConfigParseError, It as parseOsc11BackgroundTheme, J as getBreathingFrame, Jn as PRODUCT_NAME, Jt as TERMINAL_THEME_DARK, K as WelcomeComponent, Kn as CLI_UI_MODE, Kt as TERMINAL_FOCUS_IN, L as sanitizeShellOutput, Ln as TuiLikePreferencesSchema, Lt as DISABLE_TERMINAL_FOCUS_REPORTING, M as CachedContainer, Mn as hasEmbeddingModelCache, Mt as createThemeStyles, N as ThinkingComponent, Nn as startManualEmbeddingDownload, Nt as contrastTextHex, O as renderDiffLines, On as isExperimentalFlagEnabled, Ot as createMarkdownTheme, P as NoticeMessageComponent, Pn as PIXEL_PULSE_FRAMES, Pt as getColorPalette, Q as refineGoal, Qn as ScreamHarness, Qt as FooterComponent, R as SkillActivationComponent, Rn as loadTuiConfig, Rt as DISABLE_TERMINAL_THEME_REPORTING, S as readJsonlFile, Sn as getCtrlDHint, St as supportsBalance, Tn as buildSkillSlashCommands, U as getSharedSpeedTracker, Un as getLogDir, Ut as OSC11_RESPONSE_PREFIX, V as charsForTokenBudget, Vn as getDataDir, Vt as OSC11_QUERY, W as BackgroundAgentStatusComponent, Wn as detectInstallSource, Wt as OSC11_RESPONSE_PREFIX_NO_ESC, X as CompactionComponent, Xn as fetchCatalog, Xt as isBusy, Y as resetBreathingClock, Yn as DEFAULT_CATALOG_URL, Yt as TERMINAL_THEME_LIGHT, Z as clearGoalState, Zn as saveCatalogCache, Zt as isStreaming, _n as EXIT_CONFIRM_WINDOW_MS, a as syncDiagramCapabilityPrompt, an as printableChar, ar as isRealUserPrompt, at as toTerminalHyperlink, b as readUpdateCache, bn as TIP_ROTATION_INTERVAL_MS, c as disposeChildren, cn as appendStreamingArgsPreview, cr as flushDiagnosticLogs, d as isPlanExpandable, dn as isTodoItemShape, dr as isScreamError, en as SubagentSlots, er as normalizeWorkDir, f as MoonLoader, fn as parseStreamingArgs, fr as isOrphanedToolCallError, ft as handleFusionPlanCommand, gn as EMPTY_SESSION_HINT_URL, hn as truncateErrorMessage, i as buildRoleAdditionalText, it as isInternalMessage, j as langFromPath, jn as getKnowledgeStore, jt as toggleEmptySessionHint, k as renderDiffLinesClustered, kn as setExperimentalFlags, kt as isEmptySessionHintDismissed, l as hasDispose, ln as argsRecord, lr as log, mn as stringValue, mr as SCREAM_ERROR_INFO, mt as handlePlanCommand, n as clearEvalPanelState, nr as readSessionIndex, on as STATUS_BULLET, or as parseRlmMaxDepthArg, ot as changeThinkingLevel, p as formatMemoryMemoForInjection, pn as serializeToolResultOutput, pr as ErrorCodes, q as BREATHE_CYCLE_MS, qn as CLI_USER_AGENT_PRODUCT, qt as TERMINAL_FOCUS_OUT, r as openUrl, rr as removeSessionIndexEntry, sn as appendSessionHeaderHint, sr as resolveScreamHome, st as getModelCycleLevel, t as dispatchInput, tr as appendSessionIndexEntry, u as isExpandable, un as formatErrorMessage, ur as resolveGlobalLogPath, v as selectUpdateTarget, vn as MAIN_AGENT_ID, w as getDaemonInstructions, wn as getNoActiveSessionMessage, x as appendJsonlLine, xn as getCtrlCHint, xt as refreshProviderBalance, y as refreshUpdateCache, yn as SESSION_TIPS, z as AssistantMessageComponent, zn as saveTuiConfig, zt as ENABLE_TERMINAL_FOCUS_REPORTING } from "./dispatch-BGYq0dnV.mjs";
+import { a as setLocale, i as getLocale, o as t } from "./text-input-dialog-BlSqBYxO.mjs";
 import { createRequire } from "node:module";
 import { randomBytes, randomUUID, scryptSync, timingSafeEqual } from "node:crypto";
 import { access, appendFile, chmod, mkdir, mkdtemp, readFile, readdir, realpath, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
@@ -33,7 +33,7 @@ function optionalBuildString(value) {
 	return typeof value === "string" && value.length > 0 ? value : void 0;
 }
 const SCREAM_BUILD_INFO = {
-	version: optionalBuildString("0.17.7"),
+	version: optionalBuildString("0.17.9"),
 	channel: optionalBuildString(""),
 	commit: optionalBuildString(""),
 	buildTarget: optionalBuildString("darwin-arm64")
@@ -2171,6 +2171,211 @@ function renderChildRequestNotice(fields, name) {
 	};
 }
 //#endregion
+//#region src/tui/utils/subagent-instances.ts
+/**
+* agent-core synthesizes `rlm_<timestamp>_<rand>` parent tool-call ids for
+* rlm() spawns (packages/agent-core/src/agent/tool/index.ts:374), so no
+* tool-call row ever exists for them — the id shape is the only RLM marker
+* available to the TUI. A renamed prefix degrades to the generic "unknown"
+* attribution, never to a wrong one.
+*/
+const RLM_TOOL_CALL_PREFIX = "rlm_";
+/** Guard against a corrupt or cyclic parent chain hanging the render path. */
+const MAX_CHAIN_DEPTH = 16;
+function descriptionFromToolCall(call) {
+	const fromArgs = call?.args["description"];
+	if (typeof call?.description === "string" && call.description.length > 0) return call.description;
+	return typeof fromArgs === "string" && fromArgs.length > 0 ? fromArgs : void 0;
+}
+/** Snapshot a spawn event (+ the spawning tool call, still in flight at that
+*  moment) into a registry record. `spawnedAt` is passed in so a resume keeps
+*  the instance's original start time. */
+function createSubagentInstanceInfo(event, parentToolCall, spawnedAt = Date.now()) {
+	return {
+		agentId: event.subagentId,
+		type: event.subagentName,
+		description: event.description,
+		parentAgentId: event.parentAgentId,
+		parentToolCallId: event.parentToolCallId,
+		parentToolName: parentToolCall?.name,
+		parentToolDescription: descriptionFromToolCall(parentToolCall),
+		spawnedAt
+	};
+}
+/** Close a registry record on subagent.completed / subagent.failed. */
+function withSubagentInstanceEnded(info, outcome, endedAt = Date.now()) {
+	return {
+		...info,
+		endedAt,
+		outcome
+	};
+}
+/** Walk `parentAgentId` upwards, collecting parent types (nearest first). */
+function buildAncestorChain(instance, instances) {
+	const names = [];
+	const seen = new Set([instance.agentId]);
+	let parentId = instance.parentAgentId;
+	while (parentId !== void 0 && parentId !== "main" && parentId.length > 0) {
+		if (seen.has(parentId) || names.length >= MAX_CHAIN_DEPTH) return {
+			names,
+			truncated: true
+		};
+		seen.add(parentId);
+		const parent = instances.get(parentId);
+		if (parent === void 0) return {
+			names,
+			truncated: true
+		};
+		names.push(parent.type);
+		parentId = parent.parentAgentId;
+	}
+	return {
+		names,
+		truncated: false
+	};
+}
+/** Best-effort "who triggered this instance" resolution. */
+function resolveSource(instance, instances) {
+	const parentId = instance.parentAgentId;
+	const parentInstance = parentId !== void 0 && parentId !== "main" ? instances.get(parentId) : void 0;
+	const isRlm = instance.parentToolCallId.startsWith(RLM_TOOL_CALL_PREFIX);
+	if (parentInstance !== void 0) return {
+		kind: isRlm ? "rlm" : "agent",
+		name: parentInstance.type,
+		description: parentInstance.description
+	};
+	if (isRlm) return {
+		kind: "rlm",
+		name: void 0,
+		description: instance.description
+	};
+	if (instance.parentToolName !== void 0) return {
+		kind: "tool",
+		name: instance.parentToolName,
+		description: instance.parentToolDescription
+	};
+	if (parentId === void 0 || parentId === "main") return {
+		kind: "main",
+		name: void 0,
+		description: void 0
+	};
+	return {
+		kind: "unknown",
+		name: void 0,
+		description: void 0
+	};
+}
+/**
+* Map the slot snapshot + instance registry into Agents-view rows.
+*
+* One row per slot that is live or has any instance history in this session
+* (never-used slots stay out), plus one row per *registry-only* type: past
+* `MAX_SUBAGENT_SLOTS` the slot machine returns a detached slot that never
+* reaches `slots`, so the 17th+ type would otherwise spawn and finish
+* invisibly while the registry still records every instance. A synthesized
+* row is never live, takes its status from the type's latest instance
+* (`completed` / `failed`, else `idle` when nothing terminal was recorded),
+* counts every recorded instance of the type and has no `instanceId`; its
+* source and ancestors use the same derivation as slot-backed rows. Live rows
+* sort first (most recent activity on top), then ended ones by their end time.
+*
+* `recent` is the archive ring (newest last): rows derived when an instance
+* closed. A type the live snapshot no longer covers keeps its archived row, so
+* splitting the registry into live + ring does not change what the view shows
+* for anything inside the ring window. Called without `recent` (as before the
+* ring existed) the output depends on `slots` + `instances` alone.
+*/
+function buildAgentRows(slots, instances, recent = []) {
+	const byType = /* @__PURE__ */ new Map();
+	for (const info of instances.values()) {
+		const aggregate = byType.get(info.type);
+		if (aggregate === void 0) {
+			byType.set(info.type, {
+				latest: info,
+				count: 1
+			});
+			continue;
+		}
+		aggregate.count += 1;
+		if (info.spawnedAt >= aggregate.latest.spawnedAt) aggregate.latest = info;
+	}
+	const rows = [];
+	const slottedTypes = /* @__PURE__ */ new Set();
+	for (const slot of slots) {
+		slottedTypes.add(slot.type);
+		const latest = byType.get(slot.type)?.latest;
+		const live = slot.count > 0 || slot.status !== "idle";
+		if (!live && latest === void 0) continue;
+		const current = (slot.agentId === void 0 ? void 0 : instances.get(slot.agentId)) ?? latest;
+		const status = live ? slot.status : latest?.outcome ?? "idle";
+		const chain = current === void 0 ? {
+			names: [],
+			truncated: false
+		} : buildAncestorChain(current, instances);
+		const row = {
+			key: slot.type,
+			type: slot.type,
+			status,
+			live,
+			count: slot.count,
+			detail: slot.detail,
+			lastActivityAt: slot.lastActivityAt,
+			description: current?.description,
+			instanceId: live ? slot.agentId : void 0,
+			source: current === void 0 ? {
+				kind: "unknown",
+				name: void 0,
+				description: void 0
+			} : resolveSource(current, instances),
+			ancestors: chain.names,
+			chainTruncated: chain.truncated
+		};
+		const sortAt = live ? slot.lastActivityAt : latest?.endedAt ?? latest?.spawnedAt ?? slot.lastActivityAt;
+		rows.push({
+			row,
+			sortAt
+		});
+	}
+	for (const [type, aggregate] of byType) {
+		if (slottedTypes.has(type)) continue;
+		const { latest } = aggregate;
+		const activityAt = latest.endedAt ?? latest.spawnedAt;
+		const chain = buildAncestorChain(latest, instances);
+		rows.push({
+			row: {
+				key: type,
+				type,
+				status: latest.outcome ?? "idle",
+				live: false,
+				count: aggregate.count,
+				detail: void 0,
+				lastActivityAt: activityAt,
+				description: latest.description,
+				instanceId: void 0,
+				source: resolveSource(latest, instances),
+				ancestors: chain.names,
+				chainTruncated: chain.truncated
+			},
+			sortAt: activityAt
+		});
+	}
+	const coveredTypes = new Set(rows.map((entry) => entry.row.key));
+	const archivedByType = /* @__PURE__ */ new Map();
+	for (const row of recent) archivedByType.set(row.key, row);
+	for (const row of archivedByType.values()) {
+		if (coveredTypes.has(row.key)) continue;
+		rows.push({
+			row,
+			sortAt: row.lastActivityAt
+		});
+	}
+	rows.sort((a, b) => {
+		if (a.row.live !== b.row.live) return a.row.live ? -1 : 1;
+		return b.sortAt - a.sortAt;
+	});
+	return rows.map((entry) => entry.row);
+}
+//#endregion
 //#region src/tui/utils/background-task-status.ts
 const MAX_DETAIL_LENGTH = 240;
 function truncate(value) {
@@ -2505,6 +2710,17 @@ function subtractTokenUsage(current, previous) {
 function isZeroUsage(u) {
 	return u.inputOther === 0 && u.inputCacheRead === 0 && u.inputCacheCreation === 0 && u.output === 0;
 }
+/**
+* Whether a status event may patch main-agent state (RLM mode / recursion cap).
+* Only the main agent's own events qualify; subagent status updates carry their
+* own agentId and must never overwrite the main display. Events without an
+* agentId (older emitters) are accepted for backward compatibility.
+*
+* Exported (pure) so the filtering rule is unit-testable without a TUI.
+*/
+function isMainAgentStatusEvent(event) {
+	return event.agentId === void 0 || event.agentId === "main";
+}
 var SessionEventHandler = class {
 	host;
 	constructor(host) {
@@ -2531,6 +2747,22 @@ var SessionEventHandler = class {
 	subagentInfo = /* @__PURE__ */ new Map();
 	/** Sidebar subagent slot state machine (see utils/subagent-slots.ts). */
 	subagentSlots = new SubagentSlots();
+	/**
+	* Per-instance provenance registry (see utils/subagent-instances.ts), read
+	* by the /tasks browser's Agents view. Captured at spawn because the two
+	* clues stop being available later: `subagentInfo.parentToolCallId` is
+	* rewritten to a WolfPack routing id for WolfPack children, and the
+	* spawning tool call leaves the active set as soon as it returns.
+	*/
+	subagentInstances = /* @__PURE__ */ new Map();
+	/**
+	* Archive ring behind {@link getRecentSubagentInstances}: the last derived
+	* Agents-view row of every closed instance, oldest first, capped at
+	* {@link MAX_RECENT_SUBAGENT_INSTANCES}. Closing an instance releases its
+	* registry record, so this is what keeps recently-ended agents visible in the
+	* /tasks Agents view instead of letting the registry grow for the session.
+	*/
+	recentSubagentInstances = [];
 	/** Tool callId of the in-flight UpdateGoal(complete) (judging), if any. */
 	goalJudgeCallId;
 	/** Rolling first-token latencies of real requests, feeding the sidebar Hub
@@ -2551,6 +2783,8 @@ var SessionEventHandler = class {
 		this.backgroundTaskTranscriptedTerminal.clear();
 		this.subagentInfo.clear();
 		this.subagentSlots.reset();
+		this.subagentInstances.clear();
+		this.recentSubagentInstances.length = 0;
 		this.renderedSkillActivationIds.clear();
 		this.renderedMcpServerStatusKeys.clear();
 		this.stopAllMcpServerStatusSpinners();
@@ -2733,6 +2967,50 @@ var SessionEventHandler = class {
 	getSubagentSlots() {
 		return this.subagentSlots.getSlots();
 	}
+	/** Read-only snapshot of the per-instance provenance registry (Agents view
+	*  of the /tasks browser). Keyed by subagent agentId. */
+	getSubagentInstances() {
+		return this.subagentInstances;
+	}
+	/** Read-only snapshot of the archive ring: the last derived Agents-view row
+	*  of each closed instance, oldest first, bounded to
+	*  {@link MAX_RECENT_SUBAGENT_INSTANCES}. */
+	getRecentSubagentInstances() {
+		return this.recentSubagentInstances;
+	}
+	/** Remember (or refresh, on resume) one spawned instance. The spawning tool
+	*  call is resolved here, while it is still in flight. */
+	rememberSubagentInstance(event, fallbackParentAgentId) {
+		const previous = this.subagentInstances.get(event.subagentId);
+		const parentToolCall = this.host.streamingUI.getActiveToolCall(event.parentToolCallId);
+		this.subagentInstances.set(event.subagentId, createSubagentInstanceInfo({
+			...event,
+			parentAgentId: event.parentAgentId ?? fallbackParentAgentId
+		}, parentToolCall, previous?.spawnedAt));
+	}
+	/**
+	* Close an instance record on subagent.completed / subagent.failed: archive
+	* its last display row in the ring, then release the registry record — the
+	* registry is reset per session, not kept per spawned agent.
+	*
+	* The archived row is derived by the very builder the view uses (over the
+	* registry snapshot that still contains this instance and its terminal
+	* outcome), so it is field-identical to what the view rendered while the
+	* record was live; the deletion below is what makes that derivation the last
+	* chance to produce it.
+	*/
+	closeSubagentInstance(agentId, outcome) {
+		const info = this.subagentInstances.get(agentId);
+		if (info === void 0) return;
+		const ended = withSubagentInstanceEnded(info, outcome);
+		const snapshot = new Map([...this.subagentInstances, [agentId, ended]]);
+		const row = buildAgentRows(this.subagentSlots.getSlots(), snapshot).find((candidate) => candidate.key === ended.type);
+		if (row !== void 0) {
+			this.recentSubagentInstances.push(row);
+			if (this.recentSubagentInstances.length > 50) this.recentSubagentInstances.shift();
+		}
+		this.subagentInstances.delete(agentId);
+	}
 	/** Keep the last few first-token latencies, per provider. Steps without a
 	*  measured latency (no stream, cached turn) are ignored rather than counted
 	*  as a zero. */
@@ -2773,6 +3051,7 @@ var SessionEventHandler = class {
 		switch (event.type) {
 			case "subagent.spawned":
 				this.subagentSlots.onSpawned(event.subagentId, event.subagentName, event.description);
+				this.rememberSubagentInstance(event, agentId);
 				break;
 			case "subagent.started":
 				this.subagentSlots.onStarted(event.subagentId);
@@ -2780,6 +3059,7 @@ var SessionEventHandler = class {
 			case "subagent.completed":
 			case "subagent.failed":
 				this.subagentSlots.onTerminated(event.subagentId);
+				this.closeSubagentInstance(event.subagentId, event.type === "subagent.failed" ? "failed" : "completed");
 				break;
 			case "tool.call.started":
 				if (event.name === "ContactParent") {
@@ -3170,7 +3450,11 @@ var SessionEventHandler = class {
 		if (event.maxContextTokens !== void 0) patch.maxContextTokens = event.maxContextTokens;
 		if (event.planMode !== void 0) patch.planMode = event.planMode ? event.planStrategy === "fusion" ? "fusionplan" : "plan" : "off";
 		if (event.wolfpackMode !== void 0) patch.wolfpackMode = event.wolfpackMode;
-		if (event.rlmEnabled !== void 0) patch.rlmEnabled = event.rlmEnabled;
+		if (event.rlmEnabled !== void 0 || event.rlmMaxDepth !== void 0) {
+			const fromMain = isMainAgentStatusEvent(event);
+			if (fromMain && event.rlmEnabled !== void 0) patch.rlmEnabled = event.rlmEnabled;
+			if (fromMain && event.rlmMaxDepth !== void 0) patch.rlmMaxDepth = event.rlmMaxDepth;
+		}
 		if (event.permission !== void 0) patch.permissionMode = event.permission;
 		if (Object.keys(patch).length > 0) this.host.setAppState(patch);
 	}
@@ -3422,6 +3706,7 @@ var SessionEventHandler = class {
 	}
 	handleSubagentSpawned(event) {
 		this.subagentSlots.onSpawned(event.subagentId, event.subagentName, event.description);
+		this.rememberSubagentInstance(event);
 		const { streamingUI } = this.host;
 		if (streamingUI.getActiveToolCall(event.parentToolCallId)?.name === "WolfPack") {
 			const routingId = event.subagentId;
@@ -3495,6 +3780,7 @@ var SessionEventHandler = class {
 	}
 	handleSubagentCompleted(event) {
 		this.subagentSlots.onTerminated(event.subagentId);
+		this.closeSubagentInstance(event.subagentId, "completed");
 		this.recordSubagentUsage(event.subagentId, void 0, event.usage);
 		const { streamingUI } = this.host;
 		const backgroundMeta = this.backgroundAgentMetadata.get(event.subagentId);
@@ -3525,6 +3811,7 @@ var SessionEventHandler = class {
 	}
 	handleSubagentFailed(event) {
 		this.subagentSlots.onTerminated(event.subagentId);
+		this.closeSubagentInstance(event.subagentId, "failed");
 		this.recordSubagentUsage(event.subagentId, void 0, event.usage);
 		const { streamingUI } = this.host;
 		const backgroundMeta = this.backgroundAgentMetadata.get(event.subagentId);
@@ -4380,6 +4667,89 @@ function isControlCharacter(ch) {
 	const code = ch.codePointAt(0) ?? 0;
 	return code >= 0 && code <= 31 || code >= 127 && code <= 159;
 }
+/** Max characters kept across head + tail of the preview combined. */
+const UI_OUTPUT_MAX_CHARS = 8e3;
+/** Same marker string as agent-core's `result-builder.ts` TRUNCATION_MARKER. */
+const TRUNCATION_MARKER = "[...truncated]";
+function elisionMarker(elided) {
+	return `[…${String(elided)} lines elided…]`;
+}
+/**
+* Bounds one tool-output string to a head + tail preview:
+* - at most {@link UI_OUTPUT_MAX_HEAD_LINES} lines from the start and
+*   {@link UI_OUTPUT_MAX_TAIL_LINES} lines from the end (the middle is
+*   replaced with `[…N lines elided…]`);
+* - the kept head + tail text stays within {@link UI_OUTPUT_MAX_CHARS} chars,
+*   dropping whole lines first and hard-slicing a lone oversized line last
+*   (marked `[...truncated]`).
+*
+* Returns the input unchanged when it already fits both budgets.
+*/
+function boundToolOutput(output) {
+	const lines = output.split("\n");
+	const totalLines = lines.length;
+	const overflowLines = totalLines > 80;
+	const overflowChars = output.length > UI_OUTPUT_MAX_CHARS;
+	if (!overflowLines && !overflowChars) return output;
+	const head = lines.slice(0, 40);
+	const tail = overflowLines ? lines.slice(totalLines - 40) : lines.slice(40);
+	let elided = totalLines - head.length - tail.length;
+	const contentBudget = UI_OUTPUT_MAX_CHARS - 2;
+	let headText = head.join("\n");
+	let tailText = tail.join("\n");
+	while (headText.length + tailText.length > contentBudget) {
+		if (head.length > 1 && (tail.length <= 1 || headText.length >= tailText.length)) {
+			head.pop();
+			headText = head.join("\n");
+			elided += 1;
+			continue;
+		}
+		if (tail.length > 1) {
+			tail.shift();
+			tailText = tail.join("\n");
+			elided += 1;
+			continue;
+		}
+		break;
+	}
+	if (headText.length + tailText.length > contentBudget) {
+		const tailKeep = Math.min(tailText.length, Math.floor(contentBudget / 2));
+		const headKeep = Math.min(headText.length, contentBudget - tailKeep);
+		headText = headText.slice(0, headKeep);
+		tailText = tailText.slice(tailText.length - tailKeep);
+	}
+	const marker = elided > 0 ? elisionMarker(elided) : TRUNCATION_MARKER;
+	const parts = [];
+	if (headText.length > 0) parts.push(headText);
+	parts.push(marker);
+	if (tailText.length > 0) parts.push(tailText);
+	return parts.join("\n");
+}
+/**
+* Returns a transcript entry safe to keep in `state.transcriptEntries`:
+* tool-group entries get their `result.output` replaced with the bounded
+* preview (a copy — message, brief, titles, args and every other field stay
+* as they are). Non-tool entries — and tool entries already within budget —
+* come back untouched (no copy).
+*/
+function boundEntryForUi(entry) {
+	const toolCallData = entry.toolCallData;
+	if (toolCallData === void 0) return entry;
+	const result = toolCallData.result;
+	if (result === void 0) return entry;
+	const boundedOutput = boundToolOutput(result.output);
+	if (boundedOutput === result.output) return entry;
+	return {
+		...entry,
+		toolCallData: {
+			...toolCallData,
+			result: {
+				...result,
+				output: boundedOutput
+			}
+		}
+	};
+}
 //#endregion
 //#region src/tui/controllers/streaming-ui.ts
 var StreamingUIController = class StreamingUIController {
@@ -4874,9 +5244,12 @@ var StreamingUIController = class StreamingUIController {
 	}
 	/**
 	* Advance the smooth-render cursor by this frame's character budget.
-	* Budget clamps to the measured arrival rate (fast models keep up, slow
-	* models never fall behind) with a floor so the stream never freezes and a
-	* ceiling so one oversized burst is spread across frames.
+	* The base budget clamps to the measured arrival rate (slow models never
+	* fall behind) with a floor so the stream never freezes and a ceiling so one
+	* oversized burst is spread across frames. Once the backlog passes
+	* SMOOTH_CATCHUP_THRESHOLD, a catch-up budget (backlog / DIVISOR, capped at
+	* MAX_PER_FRAME) raises it so a fast stream converges to a bounded lag
+	* instead of accumulating until finalize.
 	*/
 	advanceAssistantShown() {
 		const draft = this._assistantDraft;
@@ -4884,7 +5257,9 @@ var StreamingUIController = class StreamingUIController {
 		const measured = getSharedSpeedTracker().getSpeed();
 		const tokPerSec = measured > 0 ? measured : 50;
 		const requested = charsForTokenBudget(draft.slice(this._shownAssistantLength), tokPerSec * (50 / 1e3));
-		const budget = Math.min(25, Math.max(1, requested));
+		let budget = Math.min(25, Math.max(1, requested));
+		const backlog = draft.length - this._shownAssistantLength;
+		if (backlog > 250) budget = Math.max(budget, Math.min(Math.ceil(backlog / 8), 300));
 		this._shownAssistantLength = Math.min(draft.length, this._shownAssistantLength + budget);
 		return this._shownAssistantLength;
 	}
@@ -5134,7 +5509,16 @@ var StreamingUIController = class StreamingUIController {
 			this.host.transcriptController.unmarkPending(tc);
 			this._pendingToolComponents.delete(toolCallId);
 			const entry = this.host.state.transcriptEntries.find((e) => e.toolCallData?.id === toolCallId);
-			if (entry?.toolCallData !== void 0) entry.toolCallData.result = result;
+			if (entry?.toolCallData !== void 0) {
+				const bounded = boundEntryForUi({
+					...entry,
+					toolCallData: {
+						...entry.toolCallData,
+						result
+					}
+				});
+				entry.toolCallData.result = bounded.toolCallData?.result ?? result;
+			}
 			this.host.transcriptController.commit();
 			state.ui.requestRender();
 			return;
@@ -5533,6 +5917,64 @@ function statusColor(colors, status) {
 function isTerminal(status) {
 	return status === "completed" || status === "failed" || status === "killed" || status === "lost";
 }
+/** Width of the agent-name column in the Agents list (leaves room for the
+*  status word, the instance count and an activity hint on narrow panes). */
+const AGENT_NAME_COLS = 12;
+/** Localized word per agent row status: the six live slot states plus the two
+*  terminal outcomes the instance registry can report. */
+function agentStatusText(status) {
+	switch (status) {
+		case "idle": return t("sidebar.agent_idle");
+		case "working": return t("sidebar.agent_working");
+		case "outputting": return t("sidebar.agent_outputting");
+		case "messaging": return t("sidebar.agent_messaging");
+		case "reworking": return t("sidebar.agent_reworking");
+		case "requesting": return t("sidebar.agent_requesting");
+		case "completed": return t("taskbrowser.agents_completed");
+		case "failed": return t("taskbrowser.agents_failed");
+	}
+}
+function agentStatusColor(colors, status) {
+	switch (status) {
+		case "working":
+		case "outputting": return colors.success;
+		case "messaging": return colors.accent;
+		case "reworking":
+		case "requesting": return colors.warning;
+		case "completed": return colors.textMuted;
+		case "failed": return colors.error;
+		case "idle": return colors.textDim;
+	}
+}
+/** "Who triggered this agent" line. Each kind names its own evidence, and a
+*  missing clue is voiced as unknown instead of guessed. */
+function formatAgentSource(source) {
+	switch (source.kind) {
+		case "tool":
+			if (source.name === void 0) return t("taskbrowser.agent_source_unknown");
+			return source.description === void 0 ? source.name : `${source.name} · ${source.description}`;
+		case "agent": {
+			const via = source.name === void 0 ? t("taskbrowser.agent_source_unknown") : t("taskbrowser.agent_source_via", { name: source.name });
+			return source.description === void 0 ? via : `${via} · ${source.description}`;
+		}
+		case "rlm": {
+			const rlm = t("taskbrowser.agent_source_rlm");
+			return source.name === void 0 ? rlm : `${rlm} · ${t("taskbrowser.agent_source_via", { name: source.name })}`;
+		}
+		case "main": return t("taskbrowser.agent_source_main");
+		case "unknown": return t("taskbrowser.agent_source_unknown");
+	}
+}
+/** Full spawn chain, root first: `main → researcher → coder`, `…` when the
+*  walk stopped early (missing link / cycle / depth cap). */
+function formatAgentChain(agent) {
+	const parents = [...agent.ancestors].toReversed();
+	return `${[
+		t("taskbrowser.agent_main"),
+		...parents,
+		agent.type
+	].join(" → ")}${agent.chainTruncated ? " → …" : ""}`;
+}
 function formatRelativeTime$2(ts) {
 	if (ts === null || ts === void 0 || !Number.isFinite(ts) || ts <= 0) return "";
 	const diffSec = Math.floor(Math.max(0, Date.now() - ts) / 1e3);
@@ -5560,8 +6002,22 @@ function fitExactly$1(line, width) {
 	return padToWidth$1(s, width);
 }
 function visibleTasks(tasks, filter) {
-	if (filter === "all") return [...tasks];
-	return tasks.filter((t) => !isTerminal(t.status));
+	if (filter === "active") return tasks.filter((t) => !isTerminal(t.status));
+	return [...tasks];
+}
+/**
+* Keep `selectedIndex` inside the window `scrollOffset … scrollOffset+rows-1`,
+* clamped to the list bounds. Shared by the task list and the agent list.
+*/
+function clampListScroll(selectedIndex, scrollOffset, total, visibleRows) {
+	if (visibleRows <= 0) return 0;
+	let next = scrollOffset;
+	if (selectedIndex < next) next = selectedIndex;
+	else if (selectedIndex >= next + visibleRows) next = selectedIndex - visibleRows + 1;
+	const maxScroll = Math.max(0, total - visibleRows);
+	if (next < 0) next = 0;
+	if (next > maxScroll) next = maxScroll;
+	return next;
 }
 function compareTasks(a, b) {
 	const aTerminal = isTerminal(a.status);
@@ -5601,6 +6057,12 @@ var TasksBrowserApp = class extends Container {
 	sortedVisible;
 	selectedIndex = 0;
 	listScroll = 0;
+	/** Agents view selection — component-local: agent rows are read-only, so
+	*  nothing needs to travel back to the controller. `selectedAgentKey` is the
+	*  anchor: rows re-sort as statuses change, the index must not decide. */
+	agentIndex = 0;
+	agentScroll = 0;
+	selectedAgentKey = void 0;
 	pendingStopTaskId = void 0;
 	pendingStopTimer = void 0;
 	constructor(props, terminal) {
@@ -5614,6 +6076,7 @@ var TasksBrowserApp = class extends Container {
 		this.props = next;
 		this.sortedVisible = visibleTasks(next.tasks, next.filter).toSorted(compareTasks);
 		this.syncSelectionFromProps();
+		this.syncAgentSelectionFromProps();
 		if (this.pendingStopTaskId !== void 0) {
 			const task = next.tasks.find((t) => t.taskId === this.pendingStopTaskId);
 			if (task === void 0 || isTerminal(task.status)) this.clearPendingStop();
@@ -5635,6 +6098,34 @@ var TasksBrowserApp = class extends Container {
 		}
 		if (this.selectedIndex >= this.sortedVisible.length) this.selectedIndex = this.sortedVisible.length - 1;
 	}
+	/** Keep the agents selection pinned to the same slot type across refreshes
+	*  (rows re-sort as statuses change); fall back to clamping. */
+	syncAgentSelectionFromProps() {
+		const agents = this.props.agents;
+		if (agents.length === 0) {
+			this.agentIndex = 0;
+			this.agentScroll = 0;
+			this.selectedAgentKey = void 0;
+			return;
+		}
+		if (this.selectedAgentKey !== void 0) {
+			const byKey = agents.findIndex((agent) => agent.key === this.selectedAgentKey);
+			if (byKey !== -1) {
+				this.agentIndex = byKey;
+				return;
+			}
+		}
+		if (this.agentIndex >= agents.length) this.agentIndex = agents.length - 1;
+		this.selectedAgentKey = agents[this.agentIndex]?.key;
+	}
+	/** Move the agents cursor (rows are read-only: no controller round-trip). */
+	selectAgent(index) {
+		const agents = this.props.agents;
+		if (agents.length === 0) return;
+		this.agentIndex = Math.min(agents.length - 1, Math.max(0, index));
+		this.selectedAgentKey = agents[this.agentIndex]?.key;
+		this.invalidate();
+	}
 	clearPendingStop() {
 		this.pendingStopTaskId = void 0;
 		if (this.pendingStopTimer !== void 0) {
@@ -5642,12 +6133,21 @@ var TasksBrowserApp = class extends Container {
 			this.pendingStopTimer = void 0;
 		}
 	}
+	/**
+	* Component-local teardown, called by the controller's close() before the
+	* component is swapped out: the pending-stop confirm timer must not
+	* outlive the browser.
+	*/
+	close() {
+		this.clearPendingStop();
+	}
 	emitSelect() {
 		const task = this.sortedVisible[this.selectedIndex];
 		if (task) this.props.onSelect(task.taskId);
 	}
 	handleInput(data) {
 		const k = printableChar(data);
+		const agentsMode = this.props.filter === "agents";
 		if (this.pendingStopTaskId !== void 0) {
 			if (k === "y" || k === "Y") {
 				const taskId = this.pendingStopTaskId;
@@ -5665,6 +6165,10 @@ var TasksBrowserApp = class extends Container {
 			return;
 		}
 		if (matchesKey(data, Key.up) || k === "k") {
+			if (agentsMode) {
+				this.selectAgent(this.agentIndex - 1);
+				return;
+			}
 			if (this.sortedVisible.length === 0) return;
 			this.selectedIndex = Math.max(0, this.selectedIndex - 1);
 			this.emitSelect();
@@ -5672,6 +6176,10 @@ var TasksBrowserApp = class extends Container {
 			return;
 		}
 		if (matchesKey(data, Key.down) || k === "j") {
+			if (agentsMode) {
+				this.selectAgent(this.agentIndex + 1);
+				return;
+			}
 			if (this.sortedVisible.length === 0) return;
 			this.selectedIndex = Math.min(this.sortedVisible.length - 1, this.selectedIndex + 1);
 			this.emitSelect();
@@ -5686,6 +6194,7 @@ var TasksBrowserApp = class extends Container {
 			this.props.onRefresh();
 			return;
 		}
+		if (agentsMode) return;
 		if (k === "s" || k === "S") {
 			const task = this.sortedVisible[this.selectedIndex];
 			if (task === void 0) return;
@@ -5729,15 +6238,26 @@ var TasksBrowserApp = class extends Container {
 	renderHeader(width) {
 		const colors = this.props.colors;
 		const title = chalk.hex(colors.primary).bold(" TASK BROWSER ");
-		const filterText = chalk.hex(colors.textMuted)(` filter=${this.props.filter === "all" ? "ALL" : "ACTIVE"} `);
-		const counts = countByStatus(this.props.tasks);
-		const countSegments = [];
-		if (counts.running > 0) countSegments.push(chalk.hex(colors.success)(` ${String(counts.running)} ${t("taskbrowser.running")} `));
-		if (counts.awaiting > 0) countSegments.push(chalk.hex(colors.warning)(` ${String(counts.awaiting)} ${t("taskbrowser.awaiting")} `));
-		if (counts.completed > 0) countSegments.push(chalk.hex(colors.textDim)(` ${String(counts.completed)} ${t("taskbrowser.completed")} `));
-		if (counts.terminalFailed > 0) countSegments.push(chalk.hex(colors.error)(` ${String(counts.terminalFailed)} ${t("taskbrowser.interrupted")} `));
-		const totals = chalk.hex(colors.textMuted)(` ${String(this.props.tasks.length)} ${t("taskbrowser.total")} `);
-		return fitExactly$1(title + filterText + countSegments.join("") + totals, width);
+		const filterLabel = this.props.filter === "all" ? "ALL" : this.props.filter === "active" ? "ACTIVE" : "AGENTS";
+		const filterText = chalk.hex(colors.textMuted)(` filter=${filterLabel} `);
+		const segments = [];
+		if (this.props.filter === "agents") {
+			const live = this.props.agents.filter((agent) => agent.live).length;
+			const ended = this.props.agents.length - live;
+			if (live > 0) segments.push(chalk.hex(colors.success)(` ${String(live)} ${t("taskbrowser.agents_live")} `));
+			if (ended > 0) segments.push(chalk.hex(colors.textDim)(` ${String(ended)} ${t("taskbrowser.agents_ended")} `));
+			if (this.props.agents.length === 0) segments.push(chalk.hex(colors.textMuted)(` 0 ${t("taskbrowser.agents")} `));
+		} else {
+			const counts = countByStatus(this.props.tasks);
+			if (counts.running > 0) segments.push(chalk.hex(colors.success)(` ${String(counts.running)} ${t("taskbrowser.running")} `));
+			if (counts.awaiting > 0) segments.push(chalk.hex(colors.warning)(` ${String(counts.awaiting)} ${t("taskbrowser.awaiting")} `));
+			if (counts.completed > 0) segments.push(chalk.hex(colors.textDim)(` ${String(counts.completed)} ${t("taskbrowser.completed")} `));
+			if (counts.terminalFailed > 0) segments.push(chalk.hex(colors.error)(` ${String(counts.terminalFailed)} ${t("taskbrowser.interrupted")} `));
+			segments.push(chalk.hex(colors.textMuted)(` ${String(this.props.tasks.length)} ${t("taskbrowser.total")} `));
+			const liveAgents = this.props.agents.filter((agent) => agent.live).length;
+			if (liveAgents > 0) segments.push(chalk.hex(colors.success)(` ${String(liveAgents)} ${t("taskbrowser.agents")} `));
+		}
+		return fitExactly$1(title + filterText + segments.join(""), width);
 	}
 	renderFooter(width) {
 		const colors = this.props.colors;
@@ -5747,14 +6267,19 @@ var TasksBrowserApp = class extends Container {
 			const warn = (text) => chalk.hex(colors.warning).bold(text);
 			return fitExactly$1(` ${warn(t("taskbrowser.stop"))} ${chalk.hex(colors.text)(this.pendingStopTaskId)}? ${key("Y")} ${dim(t("taskbrowser.confirm"))}  ${key("N")} ${dim(t("taskbrowser.cancel"))} `, width);
 		}
-		const left = [
+		const left = (this.props.filter === "agents" ? [
+			` ${key("↑↓")} ${dim(t("taskbrowser.select"))}`,
+			`${key("Tab")} ${dim(t("taskbrowser.filter"))}`,
+			`${key("R")} ${dim(t("taskbrowser.refresh"))}`,
+			`${key("Q/Esc")} ${dim(t("taskbrowser.exit"))} `
+		] : [
 			` ${key("↑↓")} ${dim(t("taskbrowser.select"))}`,
 			`${key("Enter/O")} ${dim(t("taskbrowser.output"))}`,
 			`${key("S")} ${dim(t("taskbrowser.stop_action"))}`,
 			`${key("R")} ${dim(t("taskbrowser.refresh"))}`,
 			`${key("Tab")} ${dim(t("taskbrowser.filter"))}`,
 			`${key("Q/Esc")} ${dim(t("taskbrowser.exit"))} `
-		].join("  ");
+		]).join("  ");
 		const flash = this.props.flashMessage;
 		if (flash !== void 0 && flash.length > 0) {
 			const flashStyled = chalk.hex(colors.warning)(` ${flash} `);
@@ -5793,6 +6318,7 @@ var TasksBrowserApp = class extends Container {
 		return lines;
 	}
 	renderListFrame(width, height) {
+		if (this.props.filter === "agents") return this.renderAgentsFrame(width, height);
 		const title = `Tasks [${this.props.filter}]`;
 		const innerHeight = Math.max(0, height - 2);
 		if (this.sortedVisible.length === 0) {
@@ -5813,6 +6339,43 @@ var TasksBrowserApp = class extends Container {
 		while (lines.length < innerHeight) lines.push("");
 		return this.renderFrame(title, lines, width, height);
 	}
+	/** Left pane, `agents` filter: one row per subagent type with history (live
+	*  ones first), including types whose slot the cap pushed out and that only
+	*  the instance registry knows; read-only — the detail pane carries the full
+	*  provenance. */
+	renderAgentsFrame(width, height) {
+		const colors = this.props.colors;
+		const agents = this.props.agents;
+		const innerHeight = Math.max(0, height - 2);
+		const title = `${t("taskbrowser.agents_title")} [${String(agents.length)}]`;
+		if (agents.length === 0) {
+			const lines = [chalk.hex(colors.textMuted)(t("taskbrowser.agents_empty"))];
+			while (lines.length < innerHeight) lines.push("");
+			return this.renderFrame(title, lines, width, height);
+		}
+		this.agentScroll = clampListScroll(this.agentIndex, this.agentScroll, agents.length, innerHeight);
+		const start = this.agentScroll;
+		const window = agents.slice(start, start + innerHeight);
+		const innerWidth = width - 2;
+		const lines = [];
+		for (const [vi, agent] of window.entries()) {
+			const index = start + vi;
+			lines.push(this.renderAgentRow(agent, index === this.agentIndex, innerWidth));
+		}
+		while (lines.length < innerHeight) lines.push("");
+		return this.renderFrame(title, lines, width, height);
+	}
+	renderAgentRow(agent, selected, innerWidth) {
+		const colors = this.props.colors;
+		const pointer = selected ? "> " : "  ";
+		const head = `${chalk.hex(selected ? colors.primary : colors.textDim)(pointer)}${chalk.hex(agentStatusColor(colors, agent.status))(agent.status === "idle" ? "○" : "●")} ${chalk.hex(selected ? colors.primary : colors.textStrong)(padToWidth$1(truncateToWidth(agent.type, AGENT_NAME_COLS, ELLIPSIS$3), AGENT_NAME_COLS))} ${chalk.hex(agentStatusColor(colors, agent.status))(agentStatusText(agent.status))}${agent.count > 1 ? chalk.hex(colors.textMuted)(` ×${String(agent.count)}`) : ""}`;
+		const budget = innerWidth - visibleWidth(head) - 1;
+		if (budget < 6) return fitExactly$1(head, innerWidth);
+		const hint = singleLine$2(agent.detail ?? agent.description ?? "");
+		if (hint.length === 0) return fitExactly$1(head, innerWidth);
+		const trimmed = truncateToWidth(hint, budget, ELLIPSIS$3);
+		return fitExactly$1(`${head} ${chalk.hex(colors.textDim)(trimmed)}`, innerWidth);
+	}
 	renderListRow(task, selected, innerWidth) {
 		const colors = this.props.colors;
 		const pointer = selected ? "> " : "  ";
@@ -5829,15 +6392,7 @@ var TasksBrowserApp = class extends Container {
 		return fitExactly$1(`${prefix} ${chalk.hex(colors.text)(desc)}`, innerWidth);
 	}
 	adjustScroll(visibleRows) {
-		if (visibleRows <= 0) {
-			this.listScroll = 0;
-			return;
-		}
-		if (this.selectedIndex < this.listScroll) this.listScroll = this.selectedIndex;
-		else if (this.selectedIndex >= this.listScroll + visibleRows) this.listScroll = this.selectedIndex - visibleRows + 1;
-		const maxScroll = Math.max(0, this.sortedVisible.length - visibleRows);
-		if (this.listScroll < 0) this.listScroll = 0;
-		if (this.listScroll > maxScroll) this.listScroll = maxScroll;
+		this.listScroll = clampListScroll(this.selectedIndex, this.listScroll, this.sortedVisible.length, visibleRows);
 	}
 	renderRightStack(width, height) {
 		const detailHeight = Math.max(8, Math.min(Math.floor(height * .4), height - 5));
@@ -5845,6 +6400,7 @@ var TasksBrowserApp = class extends Container {
 		return [...this.renderDetailFrame(width, detailHeight), ...this.renderPreviewFrame(width, previewHeight)];
 	}
 	renderDetailFrame(width, height) {
+		if (this.props.filter === "agents") return this.renderAgentDetailFrame(width, height);
 		const colors = this.props.colors;
 		const innerHeight = Math.max(0, height - 2);
 		const task = this.sortedVisible[this.selectedIndex];
@@ -5871,9 +6427,43 @@ var TasksBrowserApp = class extends Container {
 		while (lines.length < innerHeight) lines.push("");
 		return this.renderFrame(t("taskbrowser.detail"), lines, width, height);
 	}
+	/** Right-top pane, `agents` filter: provenance of the selected agent —
+	*  type, live status, spawn description, trigger source, parent chain,
+	*  latest activity and the current instance id. */
+	renderAgentDetailFrame(width, height) {
+		const colors = this.props.colors;
+		const innerHeight = Math.max(0, height - 2);
+		const agent = this.props.agents[this.agentIndex];
+		if (agent === void 0) {
+			const lines = [chalk.hex(colors.textMuted)(t("taskbrowser.agents_empty"))];
+			while (lines.length < innerHeight) lines.push("");
+			return this.renderFrame(t("taskbrowser.agent_detail"), lines, width, height);
+		}
+		const label = (text) => chalk.hex(colors.textMuted)(text.padEnd(14));
+		const value = (text) => chalk.hex(colors.text)(text);
+		const countSuffix = agent.count > 1 ? chalk.hex(colors.textMuted)(` ×${String(agent.count)}`) : "";
+		const lines = [
+			`${label(t("taskbrowser.agent_type"))}${value(agent.type)}`,
+			`${label(t("taskbrowser.status"))}${chalk.hex(agentStatusColor(colors, agent.status))(agentStatusText(agent.status))}${countSuffix}`,
+			`${label(t("taskbrowser.agent_source"))}${value(singleLine$2(formatAgentSource(agent.source)))}`,
+			`${label(t("taskbrowser.agent_chain"))}${chalk.hex(colors.textMuted)(formatAgentChain(agent))}`
+		];
+		if (agent.description !== void 0 && agent.description.length > 0) lines.push(`${label(t("taskbrowser.description"))}${value(singleLine$2(agent.description))}`);
+		if (agent.detail !== void 0 && agent.detail.length > 0) lines.push(`${label(t("taskbrowser.agent_activity"))}${value(singleLine$2(agent.detail))}`);
+		const when = formatRelativeTime$2(agent.lastActivityAt);
+		if (when.length > 0) lines.push(`${label(t("taskbrowser.time"))}${chalk.hex(colors.textMuted)(when)}`);
+		if (agent.instanceId !== void 0) lines.push(`${label(t("taskbrowser.agent_instance"))}${chalk.hex(colors.textMuted)(agent.instanceId)}`);
+		while (lines.length < innerHeight) lines.push("");
+		return this.renderFrame(t("taskbrowser.agent_detail"), lines, width, height);
+	}
 	renderPreviewFrame(width, height) {
 		const colors = this.props.colors;
 		const innerHeight = Math.max(0, height - 2);
+		if (this.props.filter === "agents") {
+			const lines = [chalk.hex(colors.textMuted)(t("taskbrowser.agents_no_output"))];
+			while (lines.length < innerHeight) lines.push("");
+			return this.renderFrame("Preview Output", lines, width, height);
+		}
 		if (this.sortedVisible[this.selectedIndex] === void 0) {
 			const lines = [chalk.hex(colors.textMuted)("No task selected.")];
 			while (lines.length < innerHeight) lines.push("");
@@ -5922,6 +6512,7 @@ var TasksBrowserController = class {
 		const selectedTaskId = this.pickInitialSelection(tasks, filter);
 		const component = new TasksBrowserApp({
 			tasks,
+			agents: this.snapshotAgentRows(),
 			filter,
 			selectedTaskId,
 			tailOutput: void 0,
@@ -5959,6 +6550,7 @@ var TasksBrowserController = class {
 		if (browser.viewer !== void 0) this.closeOutputViewer();
 		if (browser.pollTimer !== void 0) clearInterval(browser.pollTimer);
 		if (browser.flashTimer !== void 0) clearTimeout(browser.flashTimer);
+		browser.component.close();
 		state.ui.setLayoutRoot(browser.savedLayoutRoot);
 		this.host.setTasksBrowser(void 0);
 		state.ui.setFocus(state.editor);
@@ -6029,6 +6621,7 @@ var TasksBrowserController = class {
 		if (browser === void 0) return;
 		browser.component.setProps({
 			tasks,
+			agents: this.snapshotAgentRows(),
 			filter: browser.filter,
 			selectedTaskId: browser.selectedTaskId,
 			tailOutput: browser.tailOutput,
@@ -6039,6 +6632,13 @@ var TasksBrowserController = class {
 		});
 		this.host.state.ui.requestRender();
 	}
+	/** Agents view rows: the live slot state machine (authoritative status)
+	*  enriched with the per-instance provenance registry, plus the archive ring
+	*  for agents whose registry record has already been released. Rebuilt on
+	*  every refresh/repaint — all three sources are in-memory snapshots. */
+	snapshotAgentRows() {
+		return buildAgentRows(this.host.subagentSlots, this.host.subagentInstances, this.host.recentSubagentInstances);
+	}
 	buildCallbacks() {
 		return {
 			onSelect: (taskId) => {
@@ -6077,7 +6677,7 @@ var TasksBrowserController = class {
 	handleToggleFilter() {
 		const browser = this.host.state.tasksBrowser;
 		if (browser === void 0) return;
-		browser.filter = browser.filter === "all" ? "active" : "all";
+		browser.filter = browser.filter === "all" ? "active" : browser.filter === "active" ? "agents" : "all";
 		this.repaint();
 	}
 	handleRefresh() {
@@ -6346,6 +6946,28 @@ function basenameLike(raw) {
 	return raw.split(/[\\/]/).filter((part) => part.length > 0).at(-1) ?? raw;
 }
 //#endregion
+//#region src/tui/utils/collapse-stub.ts
+/**
+* The transcript bounds its memory in two places, and both stand in for the
+* rows they fold away with the same summary line: the shadow entry array
+* (`transcript-controller`) folds its oldest entries into one stub entry, and
+* the committed render tree (`committed-transcript`) folds its oldest child
+* components into one stub row. One definition of the wording keeps the two
+* folds reading alike — and lets the array fold read its own count back when
+* it folds again.
+*/
+/** Matches {@link formatCollapsedEntries} output, capturing the count. */
+const COLLAPSE_STUB_PATTERN = /^…\((\d+) earlier entries collapsed\)$/;
+/** Summary line that stands in for `count` folded-away entries. */
+function formatCollapsedEntries(count) {
+	return `…(${String(count)} earlier entries collapsed)`;
+}
+/** How many entries a summary line stands in for; 0 when `text` is not one. */
+function parseCollapsedEntries(text) {
+	const digits = COLLAPSE_STUB_PATTERN.exec(text)?.[1];
+	return digits === void 0 ? 0 : Number(digits);
+}
+//#endregion
 //#region src/tui/components/transcript/committed-transcript.ts
 var CommittedMessageComponent = class {
 	entry;
@@ -6415,6 +7037,9 @@ var CommittedTranscriptComponent = class extends CachedContainer {
 	header;
 	colors;
 	committedCount = 0;
+	/** Rows the retention cap has folded into the summary stub. */
+	collapsedCount = 0;
+	collapseStub;
 	constructor(colors) {
 		super();
 		this.colors = colors;
@@ -6424,6 +7049,12 @@ var CommittedTranscriptComponent = class extends CachedContainer {
 	getCount() {
 		return this.committedCount;
 	}
+	/** Rows the tree folded into its summary stub. They still count toward
+	*  {@link getCount()}: folding changes what is on screen, never what was
+	*  committed. */
+	getCollapsedCount() {
+		return this.collapsedCount;
+	}
 	setCount(count) {
 		this.committedCount = count;
 		if (count === 0) this.header.setText("");
@@ -6432,11 +7063,46 @@ var CommittedTranscriptComponent = class extends CachedContainer {
 	}
 	appendEntry(entry, colors) {
 		this.addChild(new CommittedMessageComponent(entry, colors));
+		this.enforceRetentionCap();
+	}
+	/**
+	* Holds the tree at its retention point: the entry children it renders —
+	* the summary stub included — never exceed MAX_COMMITTED_ENTRIES. Past that
+	* the oldest rows fold into the stub, the same semantics as the entry-array
+	* cap, so the child list (and the render cache every child carries) stops
+	* growing with the session. The stub takes one slot of the budget, so the
+	* fold lands on stub + (MAX - 1) rows: the cap is the actually retained set.
+	*/
+	enforceRetentionCap() {
+		if (this.children.length - 1 <= 500) return;
+		let stub = this.collapseStub;
+		if (stub === void 0) {
+			stub = new Text("", 0, 0);
+			this.collapseStub = stub;
+			this.children.splice(1, 0, stub);
+		}
+		const fold = this.children.length - 2 - 499;
+		this.children.splice(2, fold);
+		this.collapsedCount += fold;
+		stub.setText(`  ${chalk.hex(this.colors.textDim)(formatCollapsedEntries(this.collapsedCount))}`);
 		this.invalidate();
 	}
 };
-//#endregion
-//#region src/tui/controllers/transcript-controller.ts
+/** Id of the aggregate stub that stands in for the folded oldest entries. */
+const COLLAPSE_STUB_ID = "transcript-collapse-stub";
+function makeCollapseStub(count) {
+	return {
+		id: COLLAPSE_STUB_ID,
+		kind: "status",
+		renderMode: "plain",
+		content: formatCollapsedEntries(count)
+	};
+}
+/** Entries an existing stub already stands in for (0 when it is not one). */
+function stubCount(entry) {
+	if (entry === void 0 || entry.id !== COLLAPSE_STUB_ID) return 0;
+	return parseCollapsedEntries(entry.content);
+}
 var TranscriptController = class TranscriptController {
 	host;
 	welcomeComponent;
@@ -6446,6 +7112,17 @@ var TranscriptController = class TranscriptController {
 	*  ticker of the card that is still claiming the task is running. */
 	liveNoticesByTrackingId = /* @__PURE__ */ new Map();
 	pendingComponents = /* @__PURE__ */ new Set();
+	/** Monotonic count of composition changes to `state.transcriptEntries`:
+	*  +1 per ingest and +1 per cap fold. Aggregates that memoize over the entry
+	*  list key on this — the fold holds the array length at the cap while
+	*  replacing the oldest rows, so a length-only key can go stale. */
+	ingestCount = 0;
+	/** Contributions of the rows the entry cap has already folded out of the
+	*  array. Kept separate from the rows still held, so aggregates that must
+	*  stay monotonic over a long session (the sidebar's session stats) can add
+	*  them back — see {@link getFoldedEntryCounts}. */
+	foldedTurns = 0;
+	foldedToolCalls = 0;
 	/** Max live transcript children before the oldest are folded into the
 	*  committed single-line summary. Overridable via SCREAM_TRANSCRIPT_LIVE_LIMIT
 	*  (mirrors a commit-fold approach for bounding ultra-long sessions). */
@@ -6578,12 +7255,55 @@ var TranscriptController = class TranscriptController {
 			default: return null;
 		}
 	}
+	/**
+	* The transcript's single bounded ingress: every entry reaches
+	* `state.transcriptEntries` through here — `appendEntry` for rows that mount
+	* their own component, and `ScreamTUI.pushTranscriptEntry` for the live
+	* streaming rows that already own one. One place applies the UI preview
+	* bound (`boundEntryForUi`) and the entry-count cap, so no producer can grow
+	* the array without bound, whichever path it comes in on.
+	*
+	* Returns the entry as stored: a bounded copy when the bound rewrote it,
+	* otherwise the very entry handed in — identity matters to callers that keep
+	* mutating a live draft (assistant text, thinking) after pushing it.
+	*/
+	ingestEntry(entry) {
+		const boundedEntry = boundEntryForUi(entry);
+		this.ingestCount += 1;
+		this.host.state.transcriptEntries.push(boundedEntry);
+		this.enforceEntryCap();
+		return boundedEntry;
+	}
+	/**
+	* Monotonic count of transcript composition changes: one per ingest, plus
+	* one per cap fold. Consumers that memoize aggregates over
+	* `state.transcriptEntries` (the sidebar session stats) key on this instead
+	* of `length` alone, because a fold lands the array back on the same length
+	* while replacing its oldest rows.
+	*/
+	getIngestCount() {
+		return this.ingestCount;
+	}
+	/**
+	* What the entry cap has already folded out of `state.transcriptEntries`:
+	* user turns and real tool calls (compression markers ride kind 'tool_call'
+	* but are not invocations — same rule as the retained-row scan). Aggregates
+	* that must be monotonic over a long session — the sidebar's session stats —
+	* add these to the rows the array still holds, because the array stops
+	* holding the oldest ones at the cap.
+	*/
+	getFoldedEntryCounts() {
+		return {
+			turns: this.foldedTurns,
+			toolCalls: this.foldedToolCalls
+		};
+	}
 	appendEntry(entry) {
-		this.host.state.transcriptEntries.push(entry);
-		const component = this.createComponent(entry);
+		const boundedEntry = this.ingestEntry(entry);
+		const component = this.createComponent(boundedEntry);
 		if (component) {
-			this.liveComponentToEntry.set(component, entry);
-			const status = entry.backgroundAgentStatus;
+			this.liveComponentToEntry.set(component, boundedEntry);
+			const status = boundedEntry.backgroundAgentStatus;
 			if (status !== void 0 && component instanceof BackgroundAgentStatusComponent) {
 				const trackingId = status.trackingId;
 				if (trackingId !== void 0) if (status.phase === "started") this.liveNoticesByTrackingId.set(trackingId, component);
@@ -6597,6 +7317,24 @@ var TranscriptController = class TranscriptController {
 		}
 		return component ?? null;
 	}
+	/**
+	* Keeps `state.transcriptEntries` within {@link MAX_TRANSCRIPT_ENTRIES} by
+	* folding the oldest rows into one aggregate stub. A stub already at the head
+	* keeps that slot and accumulates the count, so the array stays bounded no
+	* matter how long the session runs.
+	*/
+	enforceEntryCap() {
+		const entries = this.host.state.transcriptEntries;
+		if (entries.length <= 500) return;
+		const head = entries[0];
+		const isStub = head !== void 0 && head.id === COLLAPSE_STUB_ID;
+		const dropped = entries.splice(0, entries.length - 500 + 1);
+		for (const entry of dropped) if (entry.kind === "user") this.foldedTurns += 1;
+		else if (entry.kind === "tool_call" && entry.compactionData === void 0) this.foldedToolCalls += 1;
+		const folded = dropped.length - (isStub ? 1 : 0);
+		entries.unshift(makeCollapseStub(stubCount(head) + folded));
+		this.ingestCount += 1;
+	}
 	/** Append a suffix to the given turn's final assistant message last line.
 	*  Used to place the turn elapsed marker flush against the last character
 	*  of the assistant's reply. Turn-scoped so a tool-only turn never stamps
@@ -6651,6 +7389,8 @@ var TranscriptController = class TranscriptController {
 		streamingUI.endActivityGroup();
 		streamingUI.flushPendingApprovals();
 		state.transcriptEntries = [];
+		this.foldedTurns = 0;
+		this.foldedToolCalls = 0;
 		streamingUI.disposeActiveCompactionBlock();
 		streamingUI.resetLiveText();
 		streamingUI.resetToolUi();
@@ -7964,7 +8704,8 @@ var LifecycleController = class LifecycleController {
 	hubProbe = createHubProbe();
 	sidebarGitCacheWorkDir = "";
 	/** Memo for the session-stats aggregation: recomputed only when the
-	* transcript length, compaction count or usage object changes. */
+	* transcript's ingest counter/length, compaction count or usage object
+	* changes. */
 	sidebarStatsMemo;
 	static MEMORY_IDLE_MS = 900 * 1e3;
 	static MEMORY_COUNTDOWN_MS = 15 * 1e3;
@@ -8231,16 +8972,20 @@ var LifecycleController = class LifecycleController {
 	}
 	readSidebarSessionStats(appState) {
 		const entries = this.host.state.transcriptEntries;
+		const ingestCount = this.host.transcriptController.getIngestCount();
 		const usage = appState.sessionUsage;
 		const subagentUsage = appState.subagentUsage;
 		const memo = this.sidebarStatsMemo;
-		if (memo !== void 0 && memo.length === entries.length && memo.compactions === appState.autoCompactionCount && memo.usage === usage && memo.subagentUsage === subagentUsage && memo.apiCalls === appState.sessionApiCalls) return memo.stats;
+		if (memo !== void 0 && memo.ingestCount === ingestCount && memo.length === entries.length && memo.compactions === appState.autoCompactionCount && memo.usage === usage && memo.subagentUsage === subagentUsage && memo.apiCalls === appState.sessionApiCalls) return memo.stats;
 		let turns = 0;
 		let toolCalls = 0;
 		for (const entry of entries) {
 			if (entry.kind === "user") turns += 1;
 			if (entry.kind === "tool_call" && entry.compactionData === void 0) toolCalls += 1;
 		}
+		const foldedAway = this.host.transcriptController.getFoldedEntryCounts();
+		turns += foldedAway.turns;
+		toolCalls += foldedAway.toolCalls;
 		let subagentOutput = 0;
 		for (const sub of Object.values(subagentUsage)) subagentOutput += sub.output;
 		const stats = {
@@ -8254,6 +8999,7 @@ var LifecycleController = class LifecycleController {
 			tokensOutput: usage.output + subagentOutput
 		};
 		this.sidebarStatsMemo = {
+			ingestCount,
 			length: entries.length,
 			compactions: appState.autoCompactionCount,
 			usage,
@@ -11159,7 +11905,7 @@ var SessionManager$1 = class {
 		this.host = host;
 	}
 	async init(options) {
-		const { startup, workDir } = options;
+		const { startup, workDir, sessionsPrefetch } = options;
 		let session;
 		let shouldReplayHistory = false;
 		const isResumeStartup = startup.sessionFlag !== void 0 || startup.continueLast;
@@ -11175,12 +11921,9 @@ var SessionManager$1 = class {
 				throw new Error("picker");
 			}
 			if (startup.sessionFlag !== void 0) {
-				const target = (await this.host.harness.listSessions({
-					sessionId: startup.sessionFlag,
-					workDir
-				}))[0];
+				const target = await this.findSessionById(startup.sessionFlag, workDir);
 				if (target === void 0) throw new Error(t("session.not_found", { sessionId: startup.sessionFlag }));
-				if (target.workDir !== workDir) throw new Error(t("session.wrong_dir", {
+				if (normalizeWorkDir(target.workDir) !== normalizeWorkDir(workDir)) throw new Error(t("session.wrong_dir", {
 					sessionId: startup.sessionFlag,
 					workDir: target.workDir
 				}));
@@ -11203,7 +11946,7 @@ var SessionManager$1 = class {
 		await this.syncRuntimeState(session);
 		if (startup.wolfpack && !isResumeStartup) await session.setWolfpackMode(true);
 		this.host.state.startupState = "ready";
-		await this.pruneEmptySessions(workDir, session.id);
+		await this.pruneEmptySessions(workDir, session.id, sessionsPrefetch);
 		this.host.sessionEventHandler.startSubscription();
 		return {
 			session,
@@ -11216,21 +11959,46 @@ var SessionManager$1 = class {
 	* one-off empty session shells. The session about to be used is skipped, as
 	* are archived sessions, any session that produced a prompt or a title, and
 	* any session touched within the grace window (protects a fresh empty
-	* session being used from another terminal). Best-effort: cleanup failures
-	* never block startup.
+	* session being used from another terminal). The prefetched listing, when
+	* present, only enumerates candidates: the snapshot can lag the splash
+	* duration, so every candidate is re-checked against a live id lookup and is
+	* deleted only if it still looks prunable right now (a session that woke up
+	* meanwhile — prompt, rename, new activity — stays). Best-effort: cleanup
+	* failures never block startup.
 	*/
-	async pruneEmptySessions(workDir, currentSessionId) {
+	async pruneEmptySessions(workDir, currentSessionId, prefetch) {
 		try {
 			const now = Date.now();
-			const summaries = await this.host.harness.listSessions({ workDir });
-			for (const summary of summaries) {
+			const normalizedWorkDir = normalizeWorkDir(workDir);
+			const candidates = prefetch === void 0 ? await this.host.harness.listSessions({ workDir }) : await prefetch;
+			for (const summary of candidates) {
 				if (summary.id === currentSessionId) continue;
-				if (isPrunableEmptySession(summary, now)) await this.host.harness.deleteSession(summary.id).catch(() => {});
+				if (!isPrunableEmptySession(summary, now)) continue;
+				const latest = (await this.host.harness.listSessions({
+					sessionId: summary.id,
+					workDir
+				}))[0];
+				if (latest === void 0) continue;
+				if (normalizeWorkDir(latest.workDir) !== normalizedWorkDir) continue;
+				if (!isPrunableEmptySession(latest, Date.now())) continue;
+				await this.host.harness.deleteSession(summary.id).catch(() => {});
 			}
 		} catch (error) {
 			this.host.showStatus(`Session cleanup skipped: ${String(error)}`);
 		}
 	}
+	/**
+	* Resolve the `--session <id>` target from a live listing (resume decisions
+	* never read the prefetched snapshot). The id-filtered form is the only call
+	* that can tell "no such session" apart from "session lives in another
+	* workDir".
+	*/
+	async findSessionById(sessionId, workDir) {
+		return (await this.host.harness.listSessions({
+			sessionId,
+			workDir
+		}))[0];
+	}
 	async setSession(session) {
 		await this.unloadCurrentSession("switching session")?.close({ extractMemories: false });
 		this.host.session = session;
@@ -11247,6 +12015,7 @@ var SessionManager$1 = class {
 			planMode: status.planMode ? status.planStrategy === "fusion" ? "fusionplan" : "plan" : "off",
 			wolfpackMode: status.wolfpackMode,
 			rlmEnabled: status.rlmEnabled,
+			rlmMaxDepth: status.rlmMaxDepth ?? null,
 			contextTokens: status.contextTokens,
 			maxContextTokens: status.maxContextTokens,
 			contextUsage: status.contextUsage,
@@ -13463,7 +14232,7 @@ var DialogManager = class {
 		}));
 	}
 	showMemoryPicker(preloadedMemos, preloadedTotal) {
-		const store = new MemoryMemoStore(getDataDir());
+		const store = sharedMemoStore(getDataDir());
 		const hasData = preloadedMemos !== void 0;
 		const memos = preloadedMemos ?? [];
 		const total = preloadedTotal ?? 0;
@@ -13628,6 +14397,7 @@ function createInitialAppState(input) {
 		ccConnectActive: false,
 		wolfpackMode: input.cliOptions.wolfpack === true,
 		rlmEnabled: false,
+		rlmMaxDepth: null,
 		reconnectAttempt: 0,
 		recentSessions: [],
 		subagentUsage: {}
@@ -13653,6 +14423,7 @@ var ScreamTUI = class {
 	/** Interval handle for the periodic provider-balance refresh. */
 	balancePollTimer;
 	updatePrefetched;
+	sessionsPrefetch;
 	sessionManager;
 	dialogManager;
 	streamingUI;
@@ -13692,6 +14463,7 @@ var ScreamTUI = class {
 		this.options = tuiOptions;
 		this.startupNotice = startupInput.startupNotice;
 		this.updatePrefetched = startupInput.updatePrefetched === true;
+		this.sessionsPrefetch = startupInput.sessionsPrefetch;
 		this.state = createTUIState(tuiOptions);
 		this.harness.setSubagentModelBindings(() => this.state.appState.subagentModels);
 		this.reverseRpcDisposers.push(...registerReverseRPCHandlers(this.approvalController, this.questionController, {
@@ -13827,7 +14599,8 @@ var ScreamTUI = class {
 		try {
 			const { shouldReplay } = await this.sessionManager.init({
 				startup: this.options.startup,
-				workDir: this.state.appState.workDir
+				workDir: this.state.appState.workDir,
+				sessionsPrefetch: this.sessionsPrefetch
 			});
 			return shouldReplay;
 		} catch (error) {
@@ -13956,7 +14729,7 @@ var ScreamTUI = class {
 		return first;
 	}
 	pushTranscriptEntry(entry) {
-		this.state.transcriptEntries.push(entry);
+		this.transcriptController.ingestEntry(entry);
 	}
 	setExternalEditorRunning(running) {
 		this.state.externalEditorRunning = running;
@@ -13973,6 +14746,21 @@ var ScreamTUI = class {
 	get backgroundTasks() {
 		return this.sessionEventHandler.backgroundTasks;
 	}
+	/** Live per-type subagent slots (sidebar state machine) — source of the
+	*  /tasks browser's Agents view. */
+	get subagentSlots() {
+		return this.sessionEventHandler.getSubagentSlots();
+	}
+	/** Per-instance subagent provenance (spawn parent / outcome / description),
+	*  keyed by agentId — source of the /tasks browser's Agents view. */
+	get subagentInstances() {
+		return this.sessionEventHandler.getSubagentInstances();
+	}
+	/** Archive ring for the Agents view: closed instances' last derived rows
+	*  (oldest first), the bounded home of agents the live map has released. */
+	get recentSubagentInstances() {
+		return this.sessionEventHandler.getRecentSubagentInstances();
+	}
 	getCurrentSessionId() {
 		return this.state.appState.sessionId;
 	}
@@ -14142,7 +14930,7 @@ var ScreamTUI = class {
 		const card = new OnboardingCardComponent({
 			colors: this.state.theme.colors,
 			onConfigure: () => {
-				import("./dispatch-Ccdic2EJ.mjs").then(({ handleConnectCommand }) => handleConnectCommand(this, "")).finally(() => {
+				import("./dispatch-DoaBG--u.mjs").then(({ handleConnectCommand }) => handleConnectCommand(this, "")).finally(() => {
 					this.restoreEditor();
 					onDone?.();
 				});
@@ -14514,7 +15302,7 @@ function supportsAnsi() {
 	ansiSupported = false;
 	return false;
 }
-async function runLoadingAnimation(theme = "dark") {
+async function runLoadingAnimation(theme, tuiConfig) {
 	if (!supportsAnsi()) {
 		const { cols } = getTerminalSize();
 		if (cols >= FULL_LOGO_MIN_COLS) for (const line of LOGO) stdout.write(`${fg(...LOGO_RGB)}${line}${RESET}\n`);
@@ -14522,10 +15310,7 @@ async function runLoadingAnimation(theme = "dark") {
 		stdout.write(`${BOLD}${fg(...THEME_PRIMARY[theme])}${t("loading.waking")}${RESET}\n`);
 		return;
 	}
-	let autoStart = false;
-	try {
-		autoStart = (await loadTuiConfig()).autoStart;
-	} catch {}
+	let autoStart = tuiConfig.autoStart;
 	const autoStartAtBoot = autoStart;
 	let toggled = false;
 	return new Promise((resolve) => {
@@ -14679,10 +15464,12 @@ async function runShell(opts, version) {
 	});
 	await harness.ensureConfigFile();
 	await harness.preflight();
+	const sessionsPrefetch = harness.listSessions({ workDir });
+	sessionsPrefetch.catch(() => {});
 	refreshUpdateCache().catch((error) => {
 		log.warn("update cache refresh failed", { error });
 	});
-	await runLoadingAnimation(resolvedTheme);
+	await runLoadingAnimation(resolvedTheme, tuiConfig);
 	const tui = new ScreamTUI(harness, {
 		cliOptions: opts,
 		tuiConfig,
@@ -14690,7 +15477,8 @@ async function runShell(opts, version) {
 		workDir,
 		startupNotice: configWarning,
 		resolvedTheme,
-		updatePrefetched: true
+		updatePrefetched: true,
+		sessionsPrefetch
 	});
 	tui.onExit = async (exitCode = 0) => {
 		const sessionId = tui.getCurrentSessionId();
@@ -16149,6 +16937,15 @@ var FileGate = class {
 * consumer of the same SDK (alongside run-shell TUI and run-stream-json),
 * not a separate engine. Zero changes to agent-core or node-sdk.
 */
+/**
+* In-memory FIFO caps per web session. The on-disk journal stays complete;
+* these bounds only stop a long-lived session from growing without limit in
+* RAM. Dropped rows are tallied so the elision stays observable (see
+* `getMemoryBounds`) — the same `[…N … elided…]` accounting the transcript
+* uses, without re-deriving it from a cursor gap.
+*/
+const MAX_JOURNAL_ENTRIES = 200;
+const MAX_SESSION_MESSAGES = 200;
 /** Thinking bodies longer than this are delivered as a tail excerpt + on-demand full text. */
 const TRUNCATE_THINKING_LEN = 8 * 1024;
 function truncateThinking(messages) {
@@ -16499,6 +17296,50 @@ const MAIN_TRANSCRIPT_EVENTS = new Set([
 	"tool.result"
 ]);
 /**
+* Identity of a persisted user-message row; used by the fork copy to drop the
+* memory copy of a row the disk already carries.
+*/
+function persistedUserMessageKey(entry) {
+	return JSON.stringify([
+		entry.beforeSeq,
+		entry.clientMessageId ?? null,
+		entry.text
+	]);
+}
+/**
+* Union of the two views of one session's durable journal, for the fork copy.
+*
+* `diskEntries` (read back from the source's journal file) is the complete
+* history and forms the base: the in-memory journal is FIFO-capped
+* (MAX_JOURNAL_ENTRIES), so a long conversation's memory only holds its tail
+* while the file keeps every row. `memoryEntries` fills the rows a
+* fire-and-forget write has not flushed yet; rows the disk already carries are
+* dropped by seq (journal rows) or identity (user messages), so no line is
+* doubled.
+*/
+function mergeForkJournalEntries(diskEntries, memoryEntries) {
+	const journalSeqs = /* @__PURE__ */ new Set();
+	const userMessageKeys = /* @__PURE__ */ new Set();
+	const journalEntries = [];
+	const userMessages = [];
+	const push = (entry) => {
+		if (entry.type === "user_message") {
+			const key = persistedUserMessageKey(entry);
+			if (userMessageKeys.has(key)) return;
+			userMessageKeys.add(key);
+			userMessages.push(entry);
+			return;
+		}
+		if (journalSeqs.has(entry.seq)) return;
+		journalSeqs.add(entry.seq);
+		journalEntries.push(entry);
+	};
+	for (const entry of diskEntries) push(entry);
+	for (const entry of memoryEntries) push(entry);
+	journalEntries.sort((a, b) => a.seq - b.seq);
+	return [...journalEntries, ...userMessages];
+}
+/**
 * Whether a journal entry already carries a message (if so it needs no seeding
 * from core history).
 */
@@ -16880,6 +17721,10 @@ var WebSession = class {
 	connections = /* @__PURE__ */ new Map();
 	journal = [];
 	userMessages = [];
+	/** Aggregate count of journal entries dropped by the FIFO cap. */
+	droppedJournalCount = 0;
+	/** Aggregate count of message rows dropped by the FIFO cap. */
+	droppedMessageCount = 0;
 	nextSeq = 1;
 	epoch = 1;
 	cachedStatus = null;
@@ -16971,7 +17816,11 @@ var WebSession = class {
 	getTitle() {
 		return this.title;
 	}
-	/** Return in-memory durable journal entries for fork copy (avoids file persistence race). */
+	/**
+	* Return the in-memory durable journal entries (capped tail). The fork copy
+	* takes these only for rows the source's journal file does not carry yet;
+	* the file itself is the complete history.
+	*/
 	getDurableJournalEntries() {
 		const entries = [];
 		for (const e of this.journal) if (!e.volatile) entries.push({
@@ -16986,6 +17835,15 @@ var WebSession = class {
 		});
 		return entries;
 	}
+	/**
+	* Drain in-flight persistence writes (journal rows, user messages, metadata).
+	* A fork reads the source's journal file afterwards and must not race a write
+	* still queued behind the serialization gate — the reader would otherwise
+	* mistake a flushed row for unsaved state.
+	*/
+	async flushPendingWrites() {
+		await Promise.allSettled(this.pendingWrites);
+	}
 	async persistEntry(entry, throwOnError = false) {
 		if (!this.homeDir) return;
 		const line = JSON.stringify({
@@ -17004,6 +17862,7 @@ var WebSession = class {
 			},
 			beforeSeq
 		});
+		this.trimMessages();
 		if (!this.homeDir) return;
 		const line = JSON.stringify({
 			type: "user_message",
@@ -17034,9 +17893,11 @@ var WebSession = class {
 				},
 				beforeSeq: um.beforeSeq
 			});
+			this.trimMessages();
 		} else {
 			const je = entry;
 			this.journal.push(je);
+			this.trimJournal();
 			this.nextSeq = Math.max(this.nextSeq, je.seq + 1);
 			if (this.session === null && je.payload.agentId === "main" && je.payload.type === "goal.updated") this.cachedGoal = cloneSnapshot(je.payload.snapshot);
 			else if (this.session === null && je.payload.agentId === "main" && je.payload.type === "todo.updated") this.cachedTodos = cloneSnapshot(je.payload.todos);
@@ -17103,6 +17964,7 @@ var WebSession = class {
 				...message,
 				seq
 			});
+			this.trimMessages();
 			seq += 1;
 		}
 		if (seq - 1 >= this.nextSeq) this.nextSeq = seq;
@@ -17126,6 +17988,44 @@ var WebSession = class {
 			permission: this.permission
 		};
 	}
+	/** FIFO-cap `journal` to `MAX_JOURNAL_ENTRIES`, tallying elided rows. */
+	trimJournal() {
+		while (this.journal.length > MAX_JOURNAL_ENTRIES) {
+			this.journal.shift();
+			this.droppedJournalCount += 1;
+		}
+	}
+	/**
+	* FIFO-cap message stores to `MAX_SESSION_MESSAGES`, tallying elided rows.
+	*
+	* Drop order follows the rendered order (`buildMessages` puts the seeded
+	* core-history rows at the head, live user rows after them), so the eviction
+	* is genuinely oldest-first and the visible tail of the conversation is what
+	* survives.
+	*/
+	trimMessages() {
+		while (this.userMessages.length + this.seededMessages.length > MAX_SESSION_MESSAGES) {
+			if (this.seededMessages.length > 0) this.seededMessages.shift();
+			else if (this.userMessages.length > 0) this.userMessages.shift();
+			else break;
+			this.droppedMessageCount += 1;
+		}
+	}
+	/**
+	* Observable surface of the in-memory FIFO caps: current occupancy, the
+	* limits, and the aggregate elided-row tallies (`[…N … elided…]` accounting,
+	* shared with the transcript).
+	*/
+	getMemoryBounds() {
+		return {
+			journal: this.journal.length,
+			journalLimit: MAX_JOURNAL_ENTRIES,
+			journalElided: this.droppedJournalCount,
+			messages: this.userMessages.length + this.seededMessages.length,
+			messageLimit: MAX_SESSION_MESSAGES,
+			messagesElided: this.droppedMessageCount
+		};
+	}
 	appendEvent(event) {
 		const payload = event.type === "goal.updated" || event.type === "todo.updated" ? cloneSnapshot(event) : event;
 		const entry = {
@@ -17135,6 +18035,7 @@ var WebSession = class {
 			payload
 		};
 		this.journal.push(entry);
+		this.trimJournal();
 		if (!entry.volatile) this.trackPending(this.persistEntry(entry));
 		return entry;
 	}
@@ -17151,6 +18052,7 @@ var WebSession = class {
 			payload
 		};
 		this.journal.push(entry);
+		this.trimJournal();
 		const persisted = this.persistEntry(entry, throwOnPersistenceError);
 		this.trackPending(persisted);
 		return {
@@ -18458,8 +19360,9 @@ var SessionManager = class {
 	}
 	/**
 	* Fork an active session: harness.forkSession copies the agent state into a
-	* new session, and we additionally copy the source's durable journal so the
-	* forked web session displays the same prior conversation.
+	* new session, and we additionally copy the source's durable journal from its
+	* journal file — the complete history, not the FIFO-capped in-memory tail —
+	* so the forked web session displays the same prior conversation.
 	*/
 	async forkSession(sourceId) {
 		const source = this.sessions.get(sourceId);
@@ -18479,13 +19382,18 @@ var SessionManager = class {
 				title,
 				onFork: (id) => this.forkSession(id)
 			});
-			const entries = source.getDurableJournalEntries();
-			if (entries.length > 0) {
+			await source.flushPendingWrites();
+			const { entries: diskEntries, corrupt } = await loadJournal(this.homeDir, sourceId);
+			const entries = mergeForkJournalEntries(diskEntries, source.getDurableJournalEntries());
+			webSession.loadFromPersisted(entries);
+			const journalHasContent = webSession.hasAnyAssistantContent();
+			const journalDamaged = corrupt > 0 && !journalHasContent;
+			if (journalDamaged) webSession.markDamaged(`journal has ${corrupt} corrupt lines and no parsed message carries a body`);
+			else if (entries.length > 0) {
 				const lines = entries.map((e) => JSON.stringify(e)).join("\n") + "\n";
 				await writeFile(getJournalPath(this.homeDir, newId), lines);
 			}
-			webSession.loadFromPersisted(entries);
-			if (!entries.some(isMessageBearingEntry)) try {
+			if (!entries.some(isMessageBearingEntry) || journalDamaged) try {
 				const context = await session.getContext();
 				webSession.seedHistory(contextHistoryToChatMessages(context.history));
 			} catch (error) {
@@ -18963,6 +19871,19 @@ function startWebIdleExit(opts) {
 		}
 	};
 }
+/**
+* Validates the optional `maxDepth` body field of the /rlm route with the same
+* grammar as /rlm-max-depth (a non-negative integer; 0 = unlimited) via the
+* shared agent-core helper. Absent / null leaves the cap untouched; any other
+* invalid value is a 400 so a client cannot silently send a cap that never
+* lands.
+*/
+function optionalRlmMaxDepth(raw) {
+	if (raw === void 0 || raw === null) return void 0;
+	const parsed = parseRlmMaxDepthArg(typeof raw === "string" ? raw : String(raw));
+	if (!parsed.ok) throw new HttpError(400, `Invalid rlm max depth: ${parsed.reason}`);
+	return parsed.value;
+}
 async function handleSessionControlRoutes(req, res, url, method, manager) {
 	const statusMatch = new RegExp(`^${API_PREFIX}/sessions/([^/]+)/status$`).exec(url);
 	if (statusMatch && method === "GET") {
@@ -19050,7 +19971,7 @@ async function handleSessionControlRoutes(req, res, url, method, manager) {
 		try {
 			const body = await readJsonBody(req);
 			const enabled = optionalBoolean(body, "enabled", true);
-			const maxDepth = typeof body["maxDepth"] === "number" ? Number(body["maxDepth"]) : void 0;
+			const maxDepth = optionalRlmMaxDepth(body["maxDepth"]);
 			await manager.setRlm(decodeURIComponent(rlmMatch[1]), enabled, maxDepth);
 			sendJson(res, 200, { ok: true });
 		} catch (error) {