1. 1#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
2. 2
3. 3//! `EntryPayload::TurnCard` (docs/design/68-context-engine.md §10): written
4. 4//! once at turn close, never model-visible raw, and a closed turn's
5. 5//! `derive_messages` slice must equal its own `full_record` exactly.
6. 6
7. 7use std::path::PathBuf;
8. 8
9. 9use tempfile::tempdir;
10. 10
11. 11use vak_llm::{ContentBlock, Message, Role};
12. 12use vak_session::types::{
13. 13 EntryPayload, FrozenContract, MessageRecord, SessionHeader, TurnCardRecord,
14. 14};
15. 15use vak_session::{Fidelity, SessionLog, TurnIndex, WorkingSetPlan};
16. 16
17. 17fn header() -> SessionHeader {
18. 18 SessionHeader {
19. 19 agent: None,
20. 20 session_id: "s-test".into(),
21. 21 created_at: chrono::Utc::now(),
22. 22 cwd: PathBuf::from("/tmp/proj"),
23. 23 parent_session_id: None,
24. 24 contract_id: None,
25. 25 work_item_id: None,
26. 26 conversation: None,
27. 27 contract: FrozenContract {
28. 28 app_version: "0.1.0".into(),
29. 29 provider: "anthropic".into(),
30. 30 model: "claude-sonnet-4-5".into(),
31. 31 route_ladder: Vec::new(),
32. 32 route_objective: String::new(),
33. 33 route_annotations: Vec::new(),
34. 34 system_prompt: "system prompt v1".into(),
35. 35 permission_mode: "workspace-write".into(),
36. 36 capabilities: Vec::new(),
37. 37 prompt_layers: Vec::new(),
38. 38 },
39. 39 }
40. 40}
41. 41
42. 42fn user_msg(text: &str) -> MessageRecord {
43. 43 MessageRecord {
44. 44 message: Message::user_text(text),
45. 45 meta: None,
46. 46 }
47. 47}
48. 48
49. 49fn assistant_msg(text: &str) -> MessageRecord {
50. 50 MessageRecord {
51. 51 message: Message::assistant(vec![ContentBlock::text(text)]),
52. 52 meta: None,
53. 53 }
54. 54}
55. 55
56. 56#[test]
57. 57fn a_turn_card_entry_round_trips_through_jsonl() {
58. 58 let dir = tempdir().unwrap();
59. 59 let path = dir.path().join("s.jsonl");
60. 60 let mut log = SessionLog::create(path.clone(), header()).unwrap();
61. 61 let turn_id = log
62. 62 .append_message(user_msg("how tall is Everest"))
63. 63 .unwrap()
64. 64 .id;
65. 65 log.append_message(assistant_msg("8,849 meters")).unwrap();
66. 66
67. 67 let index = TurnIndex::from_log(&log);
68. 68 let turn = index.turn_by_id(&turn_id).unwrap();
69. 69 let card = turn.build_card("completed", "8,849 meters".to_string(), &|s| {
70. 70 s.len() as u64 / 4
71. 71 });
72. 72 log.append_turn_card(TurnCardRecord {
73. 73 turn_id: turn_id.clone(),
74. 74 card: card.clone(),
75. 75 })
76. 76 .unwrap();
77. 77 drop(log);
78. 78
79. 79 let reopened = SessionLog::open(path).unwrap();
80. 80 let cards = reopened.turn_cards();
81. 81 assert_eq!(cards.len(), 1);
82. 82 assert_eq!(cards[0].0, turn_id);
83. 83 assert_eq!(cards[0].1.outcome, "completed");
84. 84 assert_eq!(cards[0].1.answered.narration, "8,849 meters");
85. 85}
86. 86
87. 87#[test]
88. 88fn derive_messages_skips_the_turn_card_entry() {
89. 89 let dir = tempdir().unwrap();
90. 90 let mut log = SessionLog::create(dir.path().join("s.jsonl"), header()).unwrap();
91. 91 let turn_id = log.append_message(user_msg("hi")).unwrap().id;
92. 92 log.append_message(assistant_msg("hello")).unwrap();
93. 93 let index = TurnIndex::from_log(&log);
94. 94 let card =
95. 95 index
96. 96 .turn_by_id(&turn_id)
97. 97 .unwrap()
98. 98 .build_card("completed", "hello".to_string(), &|s| s.len() as u64 / 4);
99. 99 log.append_turn_card(TurnCardRecord {
100. 100 turn_id: turn_id.clone(),
101. 101 card,
102. 102 })
103. 103 .unwrap();
104. 104
105. 105 let joined: String = log
106. 106 .derive_messages()
107. 107 .iter()
108. 108 .map(|m| m.text_content())
109. 109 .collect::<Vec<_>>()
110. 110 .join("\n");
111. 111 assert!(
112. 112 !joined.contains("outcome") && !joined.contains("tokens_full"),
113. 113 "the raw card entry must never be model-visible"
114. 114 );
115. 115 assert!(
116. 116 log.chain_to_root()
117. 117 .iter()
118. 118 .any(|e| matches!(e.payload, EntryPayload::TurnCard(_))),
119. 119 "the entry is still on the ledger, just not projected"
120. 120 );
121. 121}
122. 122
123. 123fn tool_call(id: &str, name: &str) -> MessageRecord {
124. 124 MessageRecord {
125. 125 message: Message::assistant(vec![ContentBlock::ToolUse {
126. 126 id: id.into(),
127. 127 name: name.into(),
128. 128 input: serde_json::json!({}),
129. 129 }]),
130. 130 meta: None,
131. 131 }
132. 132}
133. 133
134. 134fn tool_result(id: &str, content: &str) -> MessageRecord {
135. 135 MessageRecord {
136. 136 message: Message {
137. 137 role: Role::User,
138. 138 content: vec![ContentBlock::tool_result(id, content)],
139. 139 },
140. 140 meta: None,
141. 141 }
142. 142}
143. 143
144. 144/// No-cut invariant (docs/design/68-context-engine.md, Verification): every
145. 145/// tool result recorded in the ledger is either verbatim (the still-open
146. 146/// turn), a trace line naming its evidence id (a closed turn in the working
147. 147/// set), or covered by a compaction packet — never silently absent.
148. 148#[test]
149. 149fn every_tool_result_is_verbatim_traced_or_covered_by_a_packet() {
150. 150 let dir = tempdir().unwrap();
151. 151 let mut log = SessionLog::create(dir.path().join("s.jsonl"), header()).unwrap();
152. 152
153. 153 // Turn A: closed, will be packeted away.
154. 154 let a = log.append_message(user_msg("turn a")).unwrap().id;
155. 155 log.append_message(tool_call("ev-a", "search")).unwrap();
156. 156 log.append_message(tool_result("ev-a", "result a")).unwrap();
157. 157 log.append_message(assistant_msg("a done")).unwrap();
158. 158
159. 159 // Turn B: closed, stays in the working set as a full record.
160. 160 let b = log.append_message(user_msg("turn b")).unwrap().id;
161. 161 log.append_message(tool_call("ev-b", "search")).unwrap();
162. 162 log.append_message(tool_result("ev-b", "result b")).unwrap();
163. 163 log.append_message(assistant_msg("b done")).unwrap();
164. 164
165. 165 // Turn C: still open, stays fully verbatim.
166. 166 log.append_message(user_msg("turn c")).unwrap();
167. 167 log.append_message(tool_call("ev-c", "search")).unwrap();
168. 168 log.append_message(tool_result("ev-c", "result c")).unwrap();
169. 169
170. 170 // Packet turn A away; B rides at Full and the open C is verbatim.
171. 171 log.append_packet(&a, &a, "m", "turn a summarized".into(), 100)
172. 172 .unwrap();
173. 173 let plan = WorkingSetPlan {
174. 174 per_turn: vec![(b, Fidelity::Full)],
175. 175 packet_range: Some((a.clone(), a)),
176. 176 ..WorkingSetPlan::default()
177. 177 };
178. 178
179. 179 let messages = log.derive_with_plan(&plan);
180. 180 let joined: String = messages
181. 181 .iter()
182. 182 .map(|m| m.text_content())
183. 183 .collect::<Vec<_>>()
184. 184 .join("\n");
185. 185 let result_content = |id: &str| -> Option<String> {
186. 186 messages.iter().find_map(|m| {
187. 187 m.content.iter().find_map(|b| match b {
188. 188 ContentBlock::ToolResult {
189. 189 tool_use_id,
190. 190 content,
191. 191 ..
192. 192 } if tool_use_id == id => Some(content.clone()),
193. 193 _ => None,
194. 194 })
195. 195 })
196. 196 };
197. 197
198. 198 // ev-a: packeted — covered by the packet summary, never present as a
199. 199 // block and never digested.
200. 200 assert!(result_content("ev-a").is_none());
201. 201 assert!(!joined.contains("evidence:ev-a"));
202. 202 assert!(joined.contains("<context_summary>"));
203. 203
204. 204 // ev-b: closed and kept — the pair stays, the result is the digest
205. 205 // naming the evidence id, not the raw content.
206. 206 let b = result_content("ev-b").expect("closed turn keeps its pair");
207. 207 assert!(b.contains("[evidence:ev-b"), "{b}");
208. 208
209. 209 // ev-c: still open — verbatim.
210. 210 assert_eq!(result_content("ev-c").as_deref(), Some("result c"));
211. 211}
212. 212
213. 213#[test]
214. 214fn a_closed_turns_derive_messages_slice_equals_its_full_record() {
215. 215 let dir = tempdir().unwrap();
216. 216 let mut log = SessionLog::create(dir.path().join("s.jsonl"), header()).unwrap();
217. 217 log.append_message(user_msg("first")).unwrap();
218. 218 log.append_message(assistant_msg("first reply")).unwrap();
219. 219 log.append_message(user_msg("second")).unwrap();
220. 220 log.append_message(assistant_msg("second reply")).unwrap();
221. 221
222. 222 let index = TurnIndex::from_log(&log);
223. 223 let first_turn = &index.turns[0];
224. 224 assert!(first_turn.closed);
225. 225 let full_record = first_turn.full_record();
226. 226
227. 227 let projected = log.derive_messages();
228. 228 assert_eq!(&projected[0..2], &full_record[..]);
229. 229}
230. 230