1. 1#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
2. 2
3. 3//! Capacity activities are ledger entries but never model-visible
4. 4//! (docs/design/68-context-engine.md §1, §4): `SessionLog::latest_capacity_profile`
5. 5//! reconstructs the most recent profile for a key from `CapacityProbe` /
6. 6//! `CapacityFeedback` activities, and a session carrying them projects
7. 7//! exactly as it would without them.
8. 8//!
9. 9//! `CapacityProfile`/`ProfileKey` live in vak-agent (which depends on
10. 10//! vak-session, not the reverse), so this test stands in with small local
11. 11//! types that have the same JSON shape a real caller would serialize —
12. 12//! `latest_capacity_profile` only round-trips JSON, it never interprets it.
13. 13
14. 14use std::path::PathBuf;
15. 15
16. 16use serde::{Deserialize, Serialize};
17. 17use tempfile::tempdir;
18. 18
19. 19use vak_llm::Message;
20. 20use vak_session::SessionLog;
21. 21use vak_session::types::{
22. 22 ActivityKind, ActivityRecord, ActivityStatus, FrozenContract, MessageRecord, SessionHeader,
23. 23};
24. 24
25. 25#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
26. 26struct FakeKey {
27. 27 provider: String,
28. 28 model: String,
29. 29 quantisation: Option<String>,
30. 30}
31. 31
32. 32#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
33. 33struct FakeProfile {
34. 34 instruction_horizon_tokens: u64,
35. 35 needs_reprobe: bool,
36. 36}
37. 37
38. 38fn header() -> SessionHeader {
39. 39 SessionHeader {
40. 40 agent: None,
41. 41 session_id: "s-capacity".into(),
42. 42 created_at: chrono::Utc::now(),
43. 43 cwd: PathBuf::from("/tmp/proj"),
44. 44 parent_session_id: None,
45. 45 contract_id: None,
46. 46 work_item_id: None,
47. 47 conversation: None,
48. 48 contract: FrozenContract {
49. 49 app_version: "0.1.0".into(),
50. 50 provider: "ollama".into(),
51. 51 model: "gemma4:e2b-mlx".into(),
52. 52 route_ladder: Vec::new(),
53. 53 route_objective: String::new(),
54. 54 route_annotations: Vec::new(),
55. 55 system_prompt: "system prompt v1".into(),
56. 56 permission_mode: "workspace-write".into(),
57. 57 capabilities: Vec::new(),
58. 58 prompt_layers: Vec::new(),
59. 59 },
60. 60 }
61. 61}
62. 62
63. 63fn capacity_activity(
64. 64 kind: ActivityKind,
65. 65 key: &FakeKey,
66. 66 profile: &FakeProfile,
67. 67 id: &str,
68. 68) -> ActivityRecord {
69. 69 let mut data = std::collections::BTreeMap::new();
70. 70 data.insert("key".into(), serde_json::to_string(key).unwrap());
71. 71 data.insert("profile".into(), serde_json::to_string(profile).unwrap());
72. 72 ActivityRecord {
73. 73 activity_id: id.into(),
74. 74 turn: None,
75. 75 kind,
76. 76 status: ActivityStatus::Succeeded,
77. 77 label: "capacity".into(),
78. 78 detail: None,
79. 79 data,
80. 80 }
81. 81}
82. 82
83. 83#[test]
84. 84fn latest_capacity_profile_returns_the_most_recent_matching_entry() {
85. 85 let dir = tempdir().unwrap();
86. 86 let path = dir.path().join("capacity.jsonl");
87. 87 let mut log = SessionLog::create(path, header()).unwrap();
88. 88
89. 89 let key = FakeKey {
90. 90 provider: "ollama".into(),
91. 91 model: "gemma4:e2b-mlx".into(),
92. 92 quantisation: None,
93. 93 };
94. 94 let other_key = FakeKey {
95. 95 provider: "anthropic".into(),
96. 96 model: "claude-sonnet-5".into(),
97. 97 quantisation: None,
98. 98 };
99. 99
100. 100 let probed = FakeProfile {
101. 101 instruction_horizon_tokens: 20_000,
102. 102 needs_reprobe: false,
103. 103 };
104. 104 let fed_back = FakeProfile {
105. 105 instruction_horizon_tokens: 18_000,
106. 106 needs_reprobe: true,
107. 107 };
108. 108 let unrelated = FakeProfile {
109. 109 instruction_horizon_tokens: 100_000,
110. 110 needs_reprobe: false,
111. 111 };
112. 112
113. 113 log.append_activity(capacity_activity(
114. 114 ActivityKind::CapacityProbe,
115. 115 &key,
116. 116 &probed,
117. 117 "a1",
118. 118 ))
119. 119 .unwrap();
120. 120 log.append_activity(capacity_activity(
121. 121 ActivityKind::CapacityProbe,
122. 122 &other_key,
123. 123 &unrelated,
124. 124 "a2",
125. 125 ))
126. 126 .unwrap();
127. 127 log.append_activity(capacity_activity(
128. 128 ActivityKind::CapacityFeedback,
129. 129 &key,
130. 130 &fed_back,
131. 131 "a3",
132. 132 ))
133. 133 .unwrap();
134. 134
135. 135 let latest: FakeProfile = log
136. 136 .latest_capacity_profile(&key)
137. 137 .expect("a profile must be found for the matching key");
138. 138 assert_eq!(
139. 139 latest, fed_back,
140. 140 "feedback activity must win over the earlier probe"
141. 141 );
142. 142
143. 143 let latest_other: FakeProfile = log
144. 144 .latest_capacity_profile(&other_key)
145. 145 .expect("the other key's profile must be found independently");
146. 146 assert_eq!(latest_other, unrelated);
147. 147
148. 148 let missing_key = FakeKey {
149. 149 provider: "openai".into(),
150. 150 model: "gpt-5.6".into(),
151. 151 quantisation: None,
152. 152 };
153. 153 assert!(
154. 154 log.latest_capacity_profile::<_, FakeProfile>(&missing_key)
155. 155 .is_none()
156. 156 );
157. 157}
158. 158
159. 159#[test]
160. 160fn capacity_activities_never_change_the_model_visible_projection() {
161. 161 let dir = tempdir().unwrap();
162. 162 let path = dir.path().join("derive_parity.jsonl");
163. 163 let mut log = SessionLog::create(path, header()).unwrap();
164. 164 log.append_message(MessageRecord {
165. 165 message: Message::user_text("what's the weather"),
166. 166 meta: None,
167. 167 })
168. 168 .unwrap();
169. 169 let before = log.derive_messages();
170. 170
171. 171 let key = FakeKey {
172. 172 provider: "ollama".into(),
173. 173 model: "gemma4:e2b-mlx".into(),
174. 174 quantisation: None,
175. 175 };
176. 176 let profile = FakeProfile {
177. 177 instruction_horizon_tokens: 13_000,
178. 178 needs_reprobe: false,
179. 179 };
180. 180 log.append_activity(capacity_activity(
181. 181 ActivityKind::CapacityProbe,
182. 182 &key,
183. 183 &profile,
184. 184 "p1",
185. 185 ))
186. 186 .unwrap();
187. 187 log.append_activity(capacity_activity(
188. 188 ActivityKind::CapacityFeedback,
189. 189 &key,
190. 190 &profile,
191. 191 "p2",
192. 192 ))
193. 193 .unwrap();
194. 194
195. 195 let after = log.derive_messages();
196. 196 assert_eq!(
197. 197 before, after,
198. 198 "capacity-probe/capacity-feedback activities must never reach the model"
199. 199 );
200. 200}
201. 201