1. 1#![allow(clippy::unwrap_used, clippy::expect_used)]
2. 2
3. 3//! Control traffic is tagged structurally and carries ledger identity, so no
4. 4//! consumer has to guess from text or count messages to line things up.
5. 5
6. 6use tempfile::tempdir;
7. 7use vak_intent::control::ControlKind;
8. 8use vak_llm::{ContentBlock, Message, Role};
9. 9use vak_session::types::{FrozenContract, SessionHeader};
10. 10use vak_session::{MessageRecord, SessionLog};
11. 11
12. 12fn log(dir: &tempfile::TempDir) -> SessionLog {
13. 13 SessionLog::create(
14. 14 dir.path().join("s.jsonl"),
15. 15 SessionHeader {
16. 16 agent: None,
17. 17 session_id: "s".into(),
18. 18 created_at: chrono::Utc::now(),
19. 19 cwd: dir.path().to_path_buf(),
20. 20 parent_session_id: None,
21. 21 contract_id: None,
22. 22 work_item_id: None,
23. 23 conversation: None,
24. 24 contract: FrozenContract {
25. 25 app_version: "0".into(),
26. 26 provider: "t".into(),
27. 27 model: "t".into(),
28. 28 route_ladder: Vec::new(),
29. 29 route_objective: String::new(),
30. 30 route_annotations: Vec::new(),
31. 31 system_prompt: String::new(),
32. 32 permission_mode: "read-only".into(),
33. 33 capabilities: Vec::new(),
34. 34 prompt_layers: Vec::new(),
35. 35 },
36. 36 },
37. 37 )
38. 38 .unwrap()
39. 39}
40. 40
41. 41#[test]
42. 42fn the_structural_tag_wins_even_when_the_body_has_no_marker() {
43. 43 let record = MessageRecord::control(ControlKind::FenceCheck, "please resend");
44. 44 assert_eq!(record.control_kind(), Some(ControlKind::FenceCheck));
45. 45}
46. 46
47. 47#[test]
48. 48fn text_alone_never_makes_a_message_control() {
49. 49 // A message is control only if the runtime tagged it. One whose text
50. 50 // merely begins with a marker (a user pasting a log line, say) is the
51. 51 // user's own.
52. 52 let untagged = MessageRecord {
53. 53 message: Message::user_text("[grounding-check]: cite your results"),
54. 54 meta: None,
55. 55 };
56. 56 assert_eq!(untagged.control_kind(), None);
57. 57}
58. 58
59. 59#[test]
60. 60fn what_the_user_wrote_is_never_control() {
61. 61 for text in [
62. 62 "how did the market do",
63. 63 "[ERROR]: it broke, help",
64. 64 "see [stop-hook] docs",
65. 65 ] {
66. 66 let record = MessageRecord {
67. 67 message: Message::user_text(text),
68. 68 meta: None,
69. 69 };
70. 70 assert_eq!(record.control_kind(), None, "{text}");
71. 71 }
72. 72 let assistant = MessageRecord {
73. 73 message: Message::assistant(vec![ContentBlock::text("[fence-check]: quoting a nudge")]),
74. 74 meta: None,
75. 75 };
76. 76 assert_eq!(
77. 77 assistant.control_kind(),
78. 78 None,
79. 79 "only user-role text can be a control message"
80. 80 );
81. 81}
82. 82
83. 83#[test]
84. 84fn the_transcript_carries_identity_and_class_for_every_message() {
85. 85 let dir = tempdir().unwrap();
86. 86 let mut log = log(&dir);
87. 87 log.append_message(MessageRecord {
88. 88 message: Message::user_text("what is the weather"),
89. 89 meta: None,
90. 90 })
91. 91 .unwrap();
92. 92 log.append_message(MessageRecord {
93. 93 message: Message::assistant(vec![ContentBlock::text("sunny")]),
94. 94 meta: None,
95. 95 })
96. 96 .unwrap();
97. 97 log.append_message(MessageRecord::control(
98. 98 ControlKind::PresentationCheck,
99. 99 "[presentation-check]: use a card",
100. 100 ))
101. 101 .unwrap();
102. 102 let transcript = log.derive_transcript();
103. 103 assert_eq!(transcript.len(), 3);
104. 104 assert_eq!(transcript[0].control, None);
105. 105 assert_eq!(transcript[2].control, Some(ControlKind::PresentationCheck));
106. 106 assert_eq!(transcript[2].message.role, Role::User);
107. 107 let mut ids: Vec<_> = transcript.iter().map(|m| m.entry_id.clone()).collect();
108. 108 ids.sort();
109. 109 ids.dedup();
110. 110 assert_eq!(ids.len(), 3, "every message has its own ledger identity");
111. 111}
112. 112