scream-code 0.17.8 → 0.18.0

package/dist/{app-3vWeDa7Q.mjs → app-BuWHcggN.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-B8IVXCrX.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-DfHVLpfA.mjs";
+import { a as setLocale, i as getLocale, o as t } from "./text-input-dialog-CK6jTftM.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.8"),
+	version: optionalBuildString("0.18.0"),
 	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);
@@ -3919,6 +4206,7 @@ var SessionReplayRenderer = class {
 		this.host = host;
 	}
 	async hydrateFromReplay(session) {
+		this.host.state.ui.resetTextSelection();
 		this.host.setAppState({ isReplaying: true });
 		try {
 			const main = session.getResumeState()?.agents["main"];
@@ -4380,6 +4668,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 {
@@ -5139,7 +5510,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;
@@ -5538,6 +5918,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);
@@ -5565,8 +6003,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);
@@ -5606,6 +6058,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) {
@@ -5619,6 +6077,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();
@@ -5640,6 +6099,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) {
@@ -5647,12 +6134,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;
@@ -5670,6 +6166,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();
@@ -5677,6 +6177,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();
@@ -5691,6 +6195,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;
@@ -5734,15 +6239,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;
@@ -5752,14 +6268,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} `);
@@ -5798,6 +6319,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) {
@@ -5818,6 +6340,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 ? "> " : "  ";
@@ -5834,15 +6393,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));
@@ -5850,6 +6401,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];
@@ -5876,9 +6428,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("");
@@ -5927,6 +6513,7 @@ var TasksBrowserController = class {
 		const selectedTaskId = this.pickInitialSelection(tasks, filter);
 		const component = new TasksBrowserApp({
 			tasks,
+			agents: this.snapshotAgentRows(),
 			filter,
 			selectedTaskId,
 			tailOutput: void 0,
@@ -5964,6 +6551,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);
@@ -6034,6 +6622,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,
@@ -6044,6 +6633,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) => {
@@ -6082,7 +6678,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() {
@@ -6125,6 +6721,7 @@ var TasksBrowserController = class {
 		}
 		const current = state.tasksBrowser;
 		if (current === void 0 || current !== browser) return;
+		if (current.viewer !== void 0) return;
 		const viewer = new TaskOutputViewer({
 			taskId,
 			info: this.host.backgroundTasks.get(taskId),
@@ -6134,7 +6731,7 @@ var TasksBrowserController = class {
 				this.closeOutputViewer();
 			}
 		}, state.terminal);
-		const savedBrowserLayout = state.layoutRoot;
+		const savedBrowserLayout = browser.component;
 		state.ui.setLayoutRoot(viewer);
 		state.ui.setFocus(viewer);
 		state.ui.requestRender(true);
@@ -6351,6 +6948,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;
@@ -6420,6 +7039,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;
@@ -6429,6 +7051,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("");
@@ -6437,11 +7065,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;
@@ -6451,6 +7114,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). */
@@ -6539,6 +7213,7 @@ var TranscriptController = class TranscriptController {
 				this.dropLiveComponent(component);
 			}
 			this.committedComponent.setCount(this.committedComponent.getCount() + toCommit.length);
+			state.ui.resetTextSelection();
 			if (process.env["SCREAM_CODE_DEBUG"] === "1") this.host.showStatus(`[debug] committed=${this.committedComponent.getCount()} live=${this.getLiveCount()}`);
 			container.invalidate();
 			state.ui.requestRender();
@@ -6583,12 +7258,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);
@@ -6602,6 +7320,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
@@ -6652,10 +7388,13 @@ var TranscriptController = class TranscriptController {
 	}
 	clearAndRedraw() {
 		const { state, streamingUI, imageStore } = this.host;
+		state.ui.resetTextSelection();
 		streamingUI.discardPending();
 		streamingUI.endActivityGroup();
 		streamingUI.flushPendingApprovals();
 		state.transcriptEntries = [];
+		this.foldedTurns = 0;
+		this.foldedToolCalls = 0;
 		streamingUI.disposeActiveCompactionBlock();
 		streamingUI.resetLiveText();
 		streamingUI.resetToolUi();
@@ -6714,12 +7453,17 @@ var TranscriptController = class TranscriptController {
 		const { state } = this.host;
 		const next = !state.toolOutputExpanded;
 		const children = state.transcriptContainer.children;
+		let resized = false;
 		for (let i = children.length - 1; i >= 0; i -= 1) {
 			const child = children[i];
 			if (child === void 0) continue;
 			if (child instanceof UserMessageComponent || child instanceof SkillActivationComponent || child instanceof CronMessageComponent || child instanceof CommittedTranscriptComponent) break;
-			if (isExpandable(child)) child.setExpanded(next);
+			if (isExpandable(child)) {
+				child.setExpanded(next);
+				resized = true;
+			}
 		}
+		if (resized) state.ui.resetTextSelection();
 		state.toolOutputExpanded = next;
 		state.ui.requestRender();
 	}
@@ -6729,6 +7473,7 @@ var TranscriptController = class TranscriptController {
 		let toggled = false;
 		for (const child of state.transcriptContainer.children) if (isPlanExpandable(child) && child.setPlanExpanded(next)) toggled = true;
 		if (!toggled) return false;
+		state.ui.resetTextSelection();
 		state.planExpanded = next;
 		state.ui.requestRender();
 		return true;
@@ -7969,7 +8714,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;
@@ -8236,16 +8982,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 = {
@@ -8259,6 +9009,7 @@ var LifecycleController = class LifecycleController {
 			tokensOutput: usage.output + subagentOutput
 		};
 		this.sidebarStatsMemo = {
+			ingestCount,
 			length: entries.length,
 			compactions: appState.autoCompactionCount,
 			usage,
@@ -10194,6 +10945,7 @@ var CustomEditor = class extends Editor {
 			thinkingLevel: this.thinkingLevel,
 			toolPriority: this.toolPriority,
 			paint: this.borderColor ?? ((s) => s),
+			modeHex: getPermissionModeColor(this.permissionMode, this.colors),
 			borderHex: this.borderHex
 		});
 		return lines;
@@ -10344,6 +11096,15 @@ function injectPromptSymbol(line) {
 }
 const THINK_LABEL_MIN_WIDTH = 14;
 const MODE_BADGE_MIN_WIDTH = 10;
+function getPermissionModeColor(mode, colors) {
+	return {
+		manual: colors.permissionManual,
+		yolo: colors.permissionYolo,
+		auto: colors.permissionAuto,
+		ask: colors.permissionAsk,
+		bot: colors.permissionBot
+	}[mode];
+}
 function isLightBg(hex) {
 	const r = parseInt(hex.slice(1, 3), 16);
 	const g = parseInt(hex.slice(3, 5), 16);
@@ -10374,7 +11135,7 @@ function injectBorderBadges(lines, width, opts) {
 	let right = paint("─");
 	if (width >= MODE_BADGE_MIN_WIDTH) {
 		const badgeText = ` ${opts.mode} `;
-		left = paint("──") + (opts.borderHex ? chalk.hex(opts.borderHex).bold(badgeText) : paint(badgeText));
+		left = paint("──") + chalk.hex(opts.modeHex).bold(badgeText);
 	}
 	if (opts.thinking && width >= THINK_LABEL_MIN_WIDTH) right = makeBadge(opts.thinkingLevel !== "off" ? ` Think ${opts.thinkingLevel} ` : " Think ", opts.borderHex) + right;
 	if (opts.toolPriority === "skill" || opts.toolPriority === "mcp") right = makeBadge(` First ${opts.toolPriority} `, opts.borderHex) + paint("─") + right;
@@ -11274,6 +12035,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,
@@ -11951,6 +12713,10 @@ const DEFAULT_KEYBOARD_SHORTCUTS = [
 		keys: "Shift-Tab",
 		description: t("help.toggle_plan")
 	},
+	{
+		keys: "Tab",
+		description: t("help.cycle_thinking")
+	},
 	{
 		keys: "Ctrl-G",
 		description: t("help.external_editor")
@@ -11959,10 +12725,26 @@ const DEFAULT_KEYBOARD_SHORTCUTS = [
 		keys: "Ctrl-O",
 		description: t("help.toggle_output")
 	},
+	{
+		keys: "Ctrl-E",
+		description: t("help.toggle_plan_view")
+	},
 	{
 		keys: "Ctrl-S",
 		description: t("help.interrupt")
 	},
+	{
+		keys: "Ctrl-X",
+		description: t("help.toggle_sidebar")
+	},
+	{
+		keys: "Ctrl-B",
+		description: t("help.toggle_hint")
+	},
+	{
+		keys: "Ctrl-W",
+		description: t("help.cancel_memory")
+	},
 	{
 		keys: "Shift-Enter / Ctrl-J",
 		description: t("help.newline")
@@ -13490,7 +14272,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;
@@ -13655,6 +14437,7 @@ function createInitialAppState(input) {
 		ccConnectActive: false,
 		wolfpackMode: input.cliOptions.wolfpack === true,
 		rlmEnabled: false,
+		rlmMaxDepth: null,
 		reconnectAttempt: 0,
 		recentSessions: [],
 		subagentUsage: {}
@@ -13986,7 +14769,7 @@ var ScreamTUI = class {
 		return first;
 	}
 	pushTranscriptEntry(entry) {
-		this.state.transcriptEntries.push(entry);
+		this.transcriptController.ingestEntry(entry);
 	}
 	setExternalEditorRunning(running) {
 		this.state.externalEditorRunning = running;
@@ -14003,6 +14786,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;
 	}
@@ -14172,7 +14970,7 @@ var ScreamTUI = class {
 		const card = new OnboardingCardComponent({
 			colors: this.state.theme.colors,
 			onConfigure: () => {
-				import("./dispatch-Ba8Dz_v_.mjs").then(({ handleConnectCommand }) => handleConnectCommand(this, "")).finally(() => {
+				import("./dispatch-CUfxgLwq.mjs").then(({ handleConnectCommand }) => handleConnectCommand(this, "")).finally(() => {
 					this.restoreEditor();
 					onDone?.();
 				});
@@ -16179,6 +16977,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) {
@@ -16529,6 +17336,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).
 */
@@ -16910,6 +17761,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;
@@ -17001,7 +17856,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({
@@ -17016,6 +17875,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({
@@ -17034,6 +17902,7 @@ var WebSession = class {
 			},
 			beforeSeq
 		});
+		this.trimMessages();
 		if (!this.homeDir) return;
 		const line = JSON.stringify({
 			type: "user_message",
@@ -17064,9 +17933,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);
@@ -17133,6 +18004,7 @@ var WebSession = class {
 				...message,
 				seq
 			});
+			this.trimMessages();
 			seq += 1;
 		}
 		if (seq - 1 >= this.nextSeq) this.nextSeq = seq;
@@ -17156,6 +18028,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 = {
@@ -17165,6 +18075,7 @@ var WebSession = class {
 			payload
 		};
 		this.journal.push(entry);
+		this.trimJournal();
 		if (!entry.volatile) this.trackPending(this.persistEntry(entry));
 		return entry;
 	}
@@ -17181,6 +18092,7 @@ var WebSession = class {
 			payload
 		};
 		this.journal.push(entry);
+		this.trimJournal();
 		const persisted = this.persistEntry(entry, throwOnPersistenceError);
 		this.trackPending(persisted);
 		return {
@@ -18488,8 +19400,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);
@@ -18509,13 +19422,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) {
@@ -18993,6 +19911,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") {
@@ -19080,7 +20011,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) {