feat(Mountain): Buffer terminal output for late-listener replay

Add per-terminal output buffering to solve the same race condition that
was fixed for tree-views and SCM in 1599d76. The PTY reader task and
SkyBridge's `listen("sky://terminal/*")` installation race: in the
bundled-electron profile, the shell's first prompt fires ~50ms after
`spawn_command` while Sky's bundle still parses for ~1500ms. Without a
buffer, zsh MOTD, direnv exports, fish greetings are silently dropped
and the user sees an empty pane until they type.

The implementation adds:
- `AppendTerminalOutput()`: capture PTY bytes into a 64KB bounded buffer
  (keeps most recent suffix to preserve the prompt)
- `DrainTerminalOutputBuffer()`: retrieve all buffered terminal data
- `RemoveTerminalOutputBuffer()`: clean up on terminal exit
- Extended `sky:replay-events` to emit `sky://terminal/create` for each
  active terminal AND replay any buffered `sky://terminal/data` bytes

This completes the replay system for all three major feature areas:
tree-views, SCM providers, and terminals.

Author: NikolaRHristov

Source/Environment/TerminalProvider.rs

@@ -115,6 +115,55 @@ use tokio::sync::mpsc as TokioMPSC;
 use super::{MountainEnvironment::MountainEnvironment, Utility};
 use crate::{ApplicationState::DTO::TerminalStateDTO::TerminalStateDTO, dev_log};
 
+// Per-terminal recent-output buffer. The PTY reader task races SkyBridge's
+// `listen("sky://terminal/data", ...)` install: in the bundled-electron
+// profile, the shell's first prompt + any startup chatter (zsh's MOTD,
+// `direnv` exports, fish's greeting, …) fires within ~50 ms of
+// `localPty:createProcess` while Sky's bundle is still parsing for ~1500 ms.
+// Without buffering, those bytes vanish and the user sees an empty pane
+// until they type something to coax fresh output. We buffer up to
+// `MAX_BUFFERED_BYTES` per terminal and replay on `sky:replay-events`.
+//
+// The buffer is bounded; on overflow we drop oldest bytes (keep the most
+// recent suffix). 64 KB is enough for ~600 lines of typical zsh/bash
+// startup; tail-cropping preserves the prompt the user actually needs to
+// see.
+const MAX_BUFFERED_BYTES:usize = 64 * 1024;
+
+static TERMINAL_OUTPUT_BUFFER:std::sync::OnceLock<std::sync::Mutex<std::collections::HashMap<u64, Vec<u8>>>> =
+	std::sync::OnceLock::new();
+
+fn TerminalOutputBuffer() -> &'static std::sync::Mutex<std::collections::HashMap<u64, Vec<u8>>> {
+	TERMINAL_OUTPUT_BUFFER.get_or_init(|| std::sync::Mutex::new(std::collections::HashMap::new()))
+}
+
+pub fn AppendTerminalOutput(TerminalId:u64, Bytes:&[u8]) {
+	if let Ok(mut Map) = TerminalOutputBuffer().lock() {
+		let Entry = Map.entry(TerminalId).or_insert_with(Vec::new);
+		Entry.extend_from_slice(Bytes);
+		// Drop oldest if over cap. Keep the trailing MAX_BUFFERED_BYTES so
+		// the prompt + most-recent context survive.
+		if Entry.len() > MAX_BUFFERED_BYTES {
+			let DropCount = Entry.len() - MAX_BUFFERED_BYTES;
+			Entry.drain(..DropCount);
+		}
+	}
+}
+
+pub fn DrainTerminalOutputBuffer() -> Vec<(u64, Vec<u8>)> {
+	if let Ok(Map) = TerminalOutputBuffer().lock() {
+		Map.iter().map(|(K, V)| (*K, V.clone())).collect()
+	} else {
+		Vec::new()
+	}
+}
+
+pub fn RemoveTerminalOutputBuffer(TerminalId:u64) {
+	if let Ok(mut Map) = TerminalOutputBuffer().lock() {
+		Map.remove(&TerminalId);
+	}
+}
+
 #[async_trait]
 impl TerminalProvider for MountainEnvironment {
 	/// Creates a new terminal instance, spawns a PTY, and manages its I/O.
@@ -220,6 +269,14 @@ impl TerminalProvider for MountainEnvironment {
 			loop {
 				match PTYReader.read(&mut Buffer) {
 					Ok(count) if count > 0 => {
+						// Buffer the bytes for replay-on-late-listener. The
+						// SkyBridge install completes ~1500 ms after Cocoon
+						// activates, and the shell's first prompt fires
+						// immediately after `spawn_command`. Without a
+						// buffer the prompt is silently lost and the user
+						// sees an empty terminal pane until they type.
+						AppendTerminalOutput(TermIDForOutput, &Buffer[..count]);
+
 						let DataString = String::from_utf8_lossy(&Buffer[..count]).to_string();
 
 						// Fan out in two directions so both consumers see
@@ -329,6 +386,9 @@ impl TerminalProvider for MountainEnvironment {
 			if let Ok(mut Guard) = EnvironmentClone.ApplicationState.Feature.Terminals.ActiveTerminals.lock() {
 				Guard.remove(&TermIDForExit);
 			}
+			// Drop the recent-output replay buffer; nothing left to replay
+			// after the shell has exited.
+			RemoveTerminalOutputBuffer(TermIDForExit);
 
 			// Tell Sky the xterm panel should drop - mirrors the `sky://`
 			// create emit above. Without this, the UI keeps a ghost panel

Source/IPC/WindServiceHandlers/mod.rs

@@ -2076,6 +2076,8 @@ pub async fn mountain_ipc_invoke(app_handle:AppHandle, command:String, args:Vec<
 					let mut TreeViewCount:usize = 0;
 					let mut ScmCount:usize = 0;
 					let mut CommandCount:usize = 0;
+					let mut TerminalCount:usize = 0;
+					let mut TerminalDataBytes:usize = 0;
 					if let Ok(TreeViews) = runtime.Environment.ApplicationState.Feature.TreeViews.ActiveTreeViews.lock() {
 						for (ViewId, Dto) in TreeViews.iter() {
 							let Payload = serde_json::json!({
@@ -2164,17 +2166,62 @@ pub async fn mountain_ipc_invoke(app_handle:AppHandle, command:String, args:Vec<
 							}
 						}
 					}
+					// Replay terminals: each active terminal needs its `create`
+					// event AND any buffered stdout the PTY reader produced
+					// before SkyBridge's `listen("sky://terminal/*")` was
+					// installed. Without this, the shell's first prompt
+					// (zsh's MOTD, fish greeting, `direnv export`, …) is
+					// silently dropped and the user sees an empty pane until
+					// they type.
+					if let Ok(Terminals) = runtime
+						.Environment
+						.ApplicationState
+						.Feature
+						.Terminals
+						.ActiveTerminals
+						.lock()
+					{
+						for (TerminalId, Arc) in Terminals.iter() {
+							let (Name, Pid) = if let Ok(State) = Arc.lock() {
+								(State.Name.clone(), State.OSProcessIdentifier.unwrap_or(0))
+							} else {
+								(String::new(), 0)
+							};
+							let CreatePayload = serde_json::json!({
+								"id": *TerminalId,
+								"name": Name,
+								"pid": Pid,
+							});
+							if app_handle.emit("sky://terminal/create", CreatePayload).is_ok() {
+								TerminalCount += 1;
+							}
+						}
+					}
+					for (TerminalId, Bytes) in
+						crate::Environment::TerminalProvider::DrainTerminalOutputBuffer()
+					{
+						let DataString = String::from_utf8_lossy(&Bytes).to_string();
+						TerminalDataBytes += Bytes.len();
+						let _ = app_handle.emit(
+							"sky://terminal/data",
+							serde_json::json!({ "id": TerminalId, "data": DataString }),
+						);
+					}
 					dev_log!(
 						"sky-emit",
-						"[SkyEmit] replay-events tree-views={} scm={} commands={}",
+						"[SkyEmit] replay-events tree-views={} scm={} commands={} terminals={} terminal-bytes={}",
 						TreeViewCount,
 						ScmCount,
-						CommandCount
+						CommandCount,
+						TerminalCount,
+						TerminalDataBytes
 					);
 					Ok(serde_json::json!({
 						"treeViews": TreeViewCount,
 						"scmProviders": ScmCount,
 						"commands": CommandCount,
+						"terminals": TerminalCount,
+						"terminalDataBytes": TerminalDataBytes,
 					}))
 				},