1. 1#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
2. 2
3. 3//! Directive drift (docs/design/68-context-engine.md §7): when the thread
4. 4//! lists an earlier directive whose reading shares no domain with the
5. 5//! current one, it is marked "(earlier, now paused)" — a re-weighting, not
6. 6//! a cut. The directive itself still appears; nothing is removed.
7. 7
8. 8use std::path::PathBuf;
9. 9
10. 10use tempfile::tempdir;
11. 11
12. 12use vak_llm::{ContentBlock, Message};
13. 13use vak_session::types::{
14. 14 FrozenContract, IntentRecord, MessageRecord, SessionHeader, TurnCardRecord,
15. 15};
16. 16use vak_session::{SessionLog, TurnIndex, WorkingSetPlan};
17. 17
18. 18/// A plan that packets exactly `turn_id` (and nothing else), with the
19. 19/// packet already written — the state in which the thread has an earlier
20. 20/// directive to list.
21. 21fn packet_only(log: &mut SessionLog, turn_id: &str, summary: &str) -> WorkingSetPlan {
22. 22 log.append_packet(turn_id, turn_id, "fixture-model", summary.into(), 999)
23. 23 .unwrap();
24. 24 WorkingSetPlan {
25. 25 packet_range: Some((turn_id.to_string(), turn_id.to_string())),
26. 26 ..WorkingSetPlan::default()
27. 27 }
28. 28}
29. 29
30. 30fn header() -> SessionHeader {
31. 31 SessionHeader {
32. 32 agent: None,
33. 33 session_id: "s-drift".into(),
34. 34 created_at: chrono::Utc::now(),
35. 35 cwd: PathBuf::from("/tmp/proj"),
36. 36 parent_session_id: None,
37. 37 contract_id: None,
38. 38 work_item_id: None,
39. 39 conversation: None,
40. 40 contract: FrozenContract {
41. 41 app_version: "0.1.0".into(),
42. 42 provider: "anthropic".into(),
43. 43 model: "claude-sonnet-4-5".into(),
44. 44 route_ladder: Vec::new(),
45. 45 route_objective: String::new(),
46. 46 route_annotations: Vec::new(),
47. 47 system_prompt: "system prompt v1".into(),
48. 48 permission_mode: "workspace-write".into(),
49. 49 capabilities: Vec::new(),
50. 50 prompt_layers: Vec::new(),
51. 51 },
52. 52 }
53. 53}
54. 54
55. 55fn reading_with_domains(domains: &[&str]) -> vak_intent::Reading {
56. 56 vak_intent::Reading {
57. 57 domains: domains.iter().map(|d| d.to_string()).collect(),
58. 58 ..vak_intent::Reading::general()
59. 59 }
60. 60}
61. 61
62. 62fn user_msg(text: &str) -> MessageRecord {
63. 63 MessageRecord {
64. 64 message: Message::user_text(text),
65. 65 meta: None,
66. 66 }
67. 67}
68. 68
69. 69fn assistant_msg(text: &str) -> MessageRecord {
70. 70 MessageRecord {
71. 71 message: Message::assistant(vec![ContentBlock::text(text)]),
72. 72 meta: None,
73. 73 }
74. 74}
75. 75
76. 76fn intent_record(reading: vak_intent::Reading) -> IntentRecord {
77. 77 IntentRecord {
78. 78 reading,
79. 79 engagement: vak_intent::Engagement::general(),
80. 80 provenance: vak_intent::Provenance::new(vak_intent::Tier::General, 1, Vec::new()),
81. 81 outcome: None,
82. 82 model_visible: None,
83. 83 commitment_id: None,
84. 84 strands: Vec::new(),
85. 85 strand_commitments: Default::default(),
86. 86 }
87. 87}
88. 88
89. 89#[test]
90. 90fn a_domain_disjoint_directive_is_marked_paused_not_removed() {
91. 91 let dir = tempdir().unwrap();
92. 92 let mut log = SessionLog::create(dir.path().join("s.jsonl"), header()).unwrap();
93. 93
94. 94 // Turn 1: finance topic, closed with a card carrying that reading.
95. 95 log.append_goal_update(vak_intent::GoalUpdate {
96. 96 revision: 1,
97. 97 relation: vak_intent::GoalRelation::New,
98. 98 request: "look up the sensex".into(),
99. 99 supersedes_revision: None,
100. 100 explicit: false,
101. 101 })
102. 102 .unwrap();
103. 103 let t1 = log
104. 104 .append_message(user_msg("look up the sensex"))
105. 105 .unwrap()
106. 106 .id;
107. 107 log.append_intent(intent_record(reading_with_domains(&["finance"])))
108. 108 .unwrap();
109. 109 log.append_message(assistant_msg("sensex is up")).unwrap();
110. 110 let card1 = TurnIndex::from_log(&log)
111. 111 .turn_by_id(&t1)
112. 112 .unwrap()
113. 113 .build_card("completed", "sensex is up".to_string(), &|s| {
114. 114 s.len() as u64 / 4
115. 115 });
116. 116 log.append_turn_card(TurnCardRecord {
117. 117 turn_id: t1.clone(),
118. 118 card: card1,
119. 119 })
120. 120 .unwrap();
121. 121
122. 122 // Turn 2: unrelated cooking topic — the current directive.
123. 123 log.append_goal_update(vak_intent::GoalUpdate {
124. 124 revision: 2,
125. 125 relation: vak_intent::GoalRelation::AddsTo,
126. 126 request: "how do I poach an egg".into(),
127. 127 supersedes_revision: None,
128. 128 explicit: false,
129. 129 })
130. 130 .unwrap();
131. 131 log.append_message(user_msg("how do I poach an egg"))
132. 132 .unwrap();
133. 133 log.append_intent(intent_record(reading_with_domains(&["cooking"])))
134. 134 .unwrap();
135. 135
136. 136 // Packet turn 1 away under the plan so the thread has something to
137. 137 // list.
138. 138 let plan = packet_only(&mut log, &t1, "summary of turn 1");
139. 139
140. 140 let thread = log
141. 141 .tail_sections(Some(&plan))
142. 142 .thread
143. 143 .expect("thread must list the dropped finance directive");
144. 144 assert!(thread.contains("look up the sensex"), "{thread}");
145. 145 assert!(
146. 146 thread.contains("look up the sensex (earlier, now paused)"),
147. 147 "a domain-disjoint earlier directive must be marked paused: {thread}"
148. 148 );
149. 149}
150. 150
151. 151#[test]
152. 152fn a_domain_overlapping_directive_is_never_marked_paused() {
153. 153 let dir = tempdir().unwrap();
154. 154 let mut log = SessionLog::create(dir.path().join("s.jsonl"), header()).unwrap();
155. 155
156. 156 log.append_goal_update(vak_intent::GoalUpdate {
157. 157 revision: 1,
158. 158 relation: vak_intent::GoalRelation::New,
159. 159 request: "look up the sensex".into(),
160. 160 supersedes_revision: None,
161. 161 explicit: false,
162. 162 })
163. 163 .unwrap();
164. 164 let t1 = log
165. 165 .append_message(user_msg("look up the sensex"))
166. 166 .unwrap()
167. 167 .id;
168. 168 log.append_intent(intent_record(reading_with_domains(&["finance"])))
169. 169 .unwrap();
170. 170 log.append_message(assistant_msg("sensex is up")).unwrap();
171. 171 let card1 = TurnIndex::from_log(&log)
172. 172 .turn_by_id(&t1)
173. 173 .unwrap()
174. 174 .build_card("completed", "sensex is up".to_string(), &|s| {
175. 175 s.len() as u64 / 4
176. 176 });
177. 177 log.append_turn_card(TurnCardRecord {
178. 178 turn_id: t1.clone(),
179. 179 card: card1,
180. 180 })
181. 181 .unwrap();
182. 182
183. 183 // Turn 2: same domain (finance) — still active, never paused.
184. 184 log.append_goal_update(vak_intent::GoalUpdate {
185. 185 revision: 2,
186. 186 relation: vak_intent::GoalRelation::AddsTo,
187. 187 request: "and the nifty too".into(),
188. 188 supersedes_revision: None,
189. 189 explicit: false,
190. 190 })
191. 191 .unwrap();
192. 192 log.append_message(user_msg("and the nifty too")).unwrap();
193. 193 log.append_intent(intent_record(reading_with_domains(&["finance"])))
194. 194 .unwrap();
195. 195
196. 196 let plan = packet_only(&mut log, &t1, "summary of turn 1");
197. 197
198. 198 let thread = log
199. 199 .tail_sections(Some(&plan))
200. 200 .thread
201. 201 .expect("thread present");
202. 202 assert!(
203. 203 !thread.contains("(earlier, now paused)"),
204. 204 "same-domain directives must not be marked paused: {thread}"
205. 205 );
206. 206}
207. 207