1. 1//! Screen 4: Attention Inbox, Memory & Scheduled Automation Tasks.
2. 2//!
3. 3//! All data is real:
4. 4//! - Inbox entries derived from SSE `AgentEvent` (approvals, errors, budget alerts)
5. 5//! - Health warnings surfaced as inbox items
6. 6//! - Memory store shows real workspace path + health warnings
7. 7//! - Skill proposals and scheduled tasks derived from real session/health data
8. 8
9. 9use ratatui::buffer::Buffer;
10. 10use ratatui::layout::{Constraint, Direction, Layout, Rect};
11. 11use ratatui::style::Modifier;
12. 12use ratatui::text::{Line, Span};
13. 13use ratatui::widgets::{Block, Borders, Paragraph, Widget};
14. 14
15. 15use crate::api::HealthReport;
16. 16use crate::app::{DeckFocus, InboxEntry, InboxKind};
17. 17use crate::theme::{Symbols, Theme};
18. 18
19. 19pub struct InboxView<'a> {
20. 20 pub theme: &'a Theme,
21. 21 pub deck_focus: DeckFocus,
22. 22 pub alert_acknowledged: bool,
23. 23 pub skill_promoted: bool,
24. 24 pub watchdog_restarted: bool,
25. 25 pub inbox_entries: &'a [InboxEntry],
26. 26 pub health: &'a HealthReport,
27. 27}
28. 28
29. 29impl<'a> Widget for InboxView<'a> {
30. 30 fn render(self, area: Rect, buf: &mut Buffer) {
31. 31 let left_border = if self.deck_focus == DeckFocus::Left {
32. 32 self.theme.style_border_focus()
33. 33 } else {
34. 34 self.theme.style_border()
35. 35 };
36. 36 let right_border = if self.deck_focus == DeckFocus::Right {
37. 37 self.theme.style_border_focus()
38. 38 } else {
39. 39 self.theme.style_border()
40. 40 };
41. 41
42. 42 let deck_chunks = Layout::default()
43. 43 .direction(Direction::Horizontal)
44. 44 .constraints([Constraint::Percentage(60), Constraint::Percentage(40)])
45. 45 .split(area);
46. 46
47. 47 // -------------------------------------------------------------
48. 48 // LEFT DECK: Prioritized Attention Inbox
49. 49 // -------------------------------------------------------------
50. 50 let inbox_lines: Vec<Line> = if self.inbox_entries.is_empty() {
51. 51 vec![Line::from(vec![Span::styled(
52. 52 "Inbox is clear — awaiting real events…",
53. 53 self.theme.style_card().add_modifier(Modifier::DIM),
54. 54 )])]
55. 55 } else {
56. 56 self.inbox_entries
57. 57 .iter()
58. 58 .rev()
59. 59 .take(5)
60. 60 .map(|entry| {
61. 61 let (icon, style) = self.icon_for_kind(&entry.kind);
62. 62 let action_hint = match &entry.actionable {
63. 63 Some(_) => " [ [a] Ack ] [ [p] Promote ] [ [r] Restart ]".to_string(),
64. 64 None => String::new(),
65. 65 };
66. 66 Line::from(vec![
67. 67 Span::styled(
68. 68 format!("[{}] ", entry.timestamp),
69. 69 self.theme.style_card().add_modifier(Modifier::DIM),
70. 70 ),
71. 71 Span::styled(format!("{icon} [{:?}] ", entry.kind), style),
72. 72 Span::styled(
73. 73 &entry.title,
74. 74 self.theme.style_card().add_modifier(Modifier::BOLD),
75. 75 ),
76. 76 Span::styled(&entry.body, self.theme.style_card()),
77. 77 Span::styled(
78. 78 action_hint,
79. 79 self.theme.style_card().add_modifier(Modifier::DIM),
80. 80 ),
81. 81 ])
82. 82 })
83. 83 .collect()
84. 84 };
85. 85
86. 86 let unread_count = self
87. 87 .inbox_entries
88. 88 .iter()
89. 89 .filter(|e| !matches!(e.kind, InboxKind::Heartbeat))
90. 90 .count();
91. 91
92. 92 let inbox_block = Block::default()
93. 93 .borders(Borders::ALL)
94. 94 .border_style(left_border)
95. 95 .title(format!(
96. 96 " {} Attention Inbox ({} Unread) [Tab] ",
97. 97 Symbols::STATUS_ACTIVE,
98. 98 unread_count
99. 99 ))
100. 100 .title_style(self.theme.style_accent().add_modifier(Modifier::BOLD));
101. 101
102. 102 Paragraph::new(inbox_lines)
103. 103 .block(inbox_block)
104. 104 .render(deck_chunks[0], buf);
105. 105
106. 106 // -------------------------------------------------------------
107. 107 // RIGHT DECK: Durable Memory, Skill Proposals, Scheduled Tasks
108. 108 // -------------------------------------------------------------
109. 109 let right_chunks = Layout::default()
110. 110 .direction(Direction::Vertical)
111. 111 .constraints([
112. 112 Constraint::Percentage(40),
113. 113 Constraint::Percentage(30),
114. 114 Constraint::Percentage(30),
115. 115 ])
116. 116 .split(deck_chunks[1]);
117. 117
118. 118 // Memory Store — real from health cwd + warnings
119. 119 let mem_lines: Vec<Line> = {
120. 120 let mut lines = vec![Line::from(vec![Span::styled(
121. 121 "Workspace Memory:",
122. 122 self.theme.style_card().add_modifier(Modifier::BOLD),
123. 123 )])];
124. 124 lines.push(Line::from(vec![
125. 125 Span::styled(
126. 126 format!(" {} Path: ", Symbols::BULLET),
127. 127 self.theme.style_accent(),
128. 128 ),
129. 129 Span::styled(&self.health.cwd, self.theme.style_card()),
130. 130 ]));
131. 131 if !self.health.warnings.is_empty() {
132. 132 for w in &self.health.warnings {
133. 133 lines.push(Line::from(vec![
134. 134 Span::styled(
135. 135 format!(" {} Warning: ", Symbols::STATUS_ACTIVE),
136. 136 self.theme.style_warn(),
137. 137 ),
138. 138 Span::styled(w, self.theme.style_card()),
139. 139 ]));
140. 140 }
141. 141 } else {
142. 142 lines.push(Line::from(vec![Span::styled(
143. 143 " (no warnings)",
144. 144 self.theme.style_card().add_modifier(Modifier::DIM),
145. 145 )]));
146. 146 }
147. 147 lines
148. 148 };
149. 149
150. 150 let mem_block = Block::default()
151. 151 .borders(Borders::ALL)
152. 152 .border_style(right_border)
153. 153 .title(format!(" {} Durable Memory Store ", Symbols::BULLET))
154. 154 .title_style(self.theme.style_card());
155. 155
156. 156 Paragraph::new(mem_lines)
157. 157 .block(mem_block)
158. 158 .render(right_chunks[0], buf);
159. 159
160. 160 // Skill Proposals Queue — real from inbox entries
161. 161 let prop_entries: Vec<&InboxEntry> = self
162. 162 .inbox_entries
163. 163 .iter()
164. 164 .filter(|e| e.kind == InboxKind::SkillProposal)
165. 165 .collect();
166. 166
167. 167 let prop_lines: Vec<Line> = if prop_entries.is_empty() {
168. 168 vec![Line::from(vec![Span::styled(
169. 169 "(no skill proposals pending)",
170. 170 self.theme.style_card().add_modifier(Modifier::DIM),
171. 171 )])]
172. 172 } else {
173. 173 let mut lines = Vec::new();
174. 174 for entry in prop_entries.iter().take(3) {
175. 175 lines.push(Line::from(vec![Span::styled(
176. 176 entry.title.clone(),
177. 177 self.theme.style_card().add_modifier(Modifier::BOLD),
178. 178 )]));
179. 179 lines.push(Line::from(vec![Span::styled(
180. 180 if self.skill_promoted {
181. 181 " [ ✓ PROMOTED TO PIPELINE ]"
182. 182 } else {
183. 183 " [ [p] Promote ] [ [r] Reject ]"
184. 184 },
185. 185 if self.skill_promoted {
186. 186 self.theme.style_ok().add_modifier(Modifier::BOLD)
187. 187 } else {
188. 188 self.theme.style_card().add_modifier(Modifier::DIM)
189. 189 },
190. 190 )]));
191. 191 }
192. 192 lines
193. 193 };
194. 194
195. 195 let prop_block = Block::default()
196. 196 .borders(Borders::ALL)
197. 197 .border_style(right_border)
198. 198 .title(" Skill Proposals Queue ")
199. 199 .title_style(self.theme.style_card());
200. 200
201. 201 Paragraph::new(prop_lines)
202. 202 .block(prop_block)
203. 203 .render(right_chunks[1], buf);
204. 204
205. 205 // Scheduled Tasks & Automation — real from inbox entries
206. 206 let task_entries: Vec<&InboxEntry> = self
207. 207 .inbox_entries
208. 208 .iter()
209. 209 .filter(|e| e.kind == InboxKind::ScheduledTask)
210. 210 .collect();
211. 211
212. 212 let task_lines: Vec<Line> = if task_entries.is_empty() {
213. 213 vec![Line::from(vec![Span::styled(
214. 214 "(no scheduled tasks reported)",
215. 215 self.theme.style_card().add_modifier(Modifier::DIM),
216. 216 )])]
217. 217 } else {
218. 218 task_entries
219. 219 .iter()
220. 220 .take(4)
221. 221 .map(|entry| {
222. 222 let status_icon = if entry.body.contains("Next:") {
223. 223 Symbols::STATUS_ACTIVE
224. 224 } else {
225. 225 Symbols::CHECK
226. 226 };
227. 227 Line::from(vec![
228. 228 Span::styled(
229. 229 format!("{} {} ", status_icon, entry.title),
230. 230 self.theme.style_ok(),
231. 231 ),
232. 232 Span::styled(
233. 233 &entry.body,
234. 234 self.theme.style_card().add_modifier(Modifier::DIM),
235. 235 ),
236. 236 ])
237. 237 })
238. 238 .collect()
239. 239 };
240. 240
241. 241 let task_block = Block::default()
242. 242 .borders(Borders::ALL)
243. 243 .border_style(right_border)
244. 244 .title(" Scheduled Tasks & Automation ")
245. 245 .title_style(self.theme.style_card());
246. 246
247. 247 Paragraph::new(task_lines)
248. 248 .block(task_block)
249. 249 .render(right_chunks[2], buf);
250. 250 }
251. 251}
252. 252
253. 253impl<'a> InboxView<'a> {
254. 254 fn icon_for_kind(&self, kind: &InboxKind) -> (&'static str, ratatui::style::Style) {
255. 255 match kind {
256. 256 InboxKind::BudgetAlert => (
257. 257 Symbols::CROSS,
258. 258 self.theme.style_danger().add_modifier(Modifier::BOLD),
259. 259 ),
260. 260 InboxKind::ApprovalPending => (
261. 261 Symbols::STATUS_ACTIVE,
262. 262 self.theme.style_warn().add_modifier(Modifier::BOLD),
263. 263 ),
264. 264 InboxKind::ApprovalDenied => (
265. 265 Symbols::CROSS,
266. 266 self.theme.style_danger().add_modifier(Modifier::BOLD),
267. 267 ),
268. 268 InboxKind::WatchdogFailure => (
269. 269 Symbols::CROSS,
270. 270 self.theme.style_danger().add_modifier(Modifier::BOLD),
271. 271 ),
272. 272 InboxKind::SkillProposal => (
273. 273 Symbols::STATUS_ACTIVE,
274. 274 self.theme.style_info().add_modifier(Modifier::BOLD),
275. 275 ),
276. 276 InboxKind::ScheduledTask => (
277. 277 Symbols::STATUS_ACTIVE,
278. 278 self.theme.style_ok().add_modifier(Modifier::BOLD),
279. 279 ),
280. 280 InboxKind::Heartbeat => (
281. 281 Symbols::STATUS_IDLE,
282. 282 self.theme.style_card().add_modifier(Modifier::DIM),
283. 283 ),
284. 284 }
285. 285 }
286. 286}
287. 287