1. 1//! Comprehensive scenario testing for the vak-intent kernel.
2. 2//!
3. 3//! This file exercises every axis of the reading, the resolution cascade, the
4. 4//! narrowing lattice, authority composition, and engagement derivation across
5. 5//! thousands of generated and hand-written scenarios spanning ordinary usage,
6. 6//! edge cases, adversarial inputs, and the full combinatorial space.
7. 7//!
8. 8//! Run with: `cargo test -p vak-intent --test scenarios`
9. 9
10. 10#![allow(
11. 11 clippy::unwrap_used,
12. 12 clippy::expect_used,
13. 13 clippy::panic,
14. 14 clippy::type_complexity
15. 15)]
16. 16
17. 17use std::collections::{BTreeMap, BTreeSet};
18. 18
19. 19use chrono::Utc;
20. 20
21. 21use vak_intent::authority::{
22. 22 ApprovalCeiling, Authority, Autonomy, Envelope, Escalation, GateFallback, PermissionCeiling,
23. 23};
24. 24use vak_intent::axes::{
25. 25 Act, Attendance, Clarity, Evidence, Horizon, Modality, Satisfaction, Stakes,
26. 26};
27. 27use vak_intent::engage::{
28. 28 Cadence, ClarifyPolicy, ContextProfile, Engagement, HilMode, OutputShape, StopProfile, Urgency,
29. 29 derive,
30. 30};
31. 31use vak_intent::goal::{GoalControlState, GoalRelation, GoalState, GoalUpdate};
32. 32use vak_intent::limits::{DomainSet, Limits};
33. 33use vak_intent::outcome::{
34. 34 CompletionVerdict, EvidenceState, OutcomeSpec, OutcomeStatus, RequirementEvaluation,
35. 35 RequirementStatus, evaluate_completion, evaluate_requirements, evidence_state_from_age,
36. 36 human_review_state,
37. 37};
38. 38use vak_intent::reading::{Confidences, Intent, Reading, Tier};
39. 39use vak_intent::resolve::{
40. 40 Classification, Declared, Resolution, ResolverConfig, apply_classification, apply_envelopes,
41. 41 resolve,
42. 42};
43. 43use vak_intent::signals::{
44. 44 Attachment, HistoryFacts, Request, Surface, Votes, WorkspaceFacts, extract,
45. 45};
46. 46
47. 47// ================================================================ helpers ===
48. 48
49. 49fn req(text: &str) -> Request<'_> {
50. 50 Request {
51. 51 text,
52. 52 surface: Surface::Cli,
53. 53 ..Request::default()
54. 54 }
55. 55}
56. 56
57. 57fn req_full(
58. 58 text: &str,
59. 59 surface: Surface,
60. 60 is_repo: bool,
61. 61 has_uncommitted: bool,
62. 62 previous_act: Option<Act>,
63. 63 turn_index: usize,
64. 64) -> Request<'_> {
65. 65 Request {
66. 66 text,
67. 67 surface,
68. 68 workspace: WorkspaceFacts {
69. 69 is_repo,
70. 70 has_uncommitted_changes: has_uncommitted,
71. 71 },
72. 72 history: HistoryFacts {
73. 73 previous_act,
74. 74 turn_index,
75. 75 open_threads: Vec::new(),
76. 76 },
77. 77 ..Request::default()
78. 78 }
79. 79}
80. 80
81. 81fn resolve_text(text: &str) -> Intent {
82. 82 resolve(
83. 83 &req(text),
84. 84 &Declared::default(),
85. 85 &Authority::default(),
86. 86 &ResolverConfig::default(),
87. 87 )
88. 88 .intent()
89. 89}
90. 90
91. 91fn resolve_declared(text: &str, declared: &Declared) -> Intent {
92. 92 resolve(
93. 93 &req(text),
94. 94 declared,
95. 95 &Authority::default(),
96. 96 &ResolverConfig::default(),
97. 97 )
98. 98 .intent()
99. 99}
100. 100
101. 101fn reading_simple(act: Act, horizon: Horizon, stakes: Stakes, evidence: Evidence) -> Reading {
102. 102 Reading {
103. 103 act,
104. 104 horizon,
105. 105 stakes,
106. 106 evidence,
107. 107 confidence: 0.95,
108. 108 axis_confidence: Confidences {
109. 109 act: 0.95,
110. 110 horizon: 0.95,
111. 111 stakes: 0.95,
112. 112 evidence: 0.95,
113. 113 },
114. 114 ..Reading::general()
115. 115 }
116. 116}
117. 117
118. 118fn authority_of(autonomy: Autonomy, attendance: Attendance) -> Authority {
119. 119 Authority {
120. 120 autonomy,
121. 121 attendance,
122. 122 }
123. 123}
124. 124
125. 125fn test_envelope(ceiling: PermissionCeiling) -> Envelope {
126. 126 Envelope {
127. 127 envelope_id: "env-1".into(),
128. 128 granted_by: "operator".into(),
129. 129 granted_at: chrono::Utc::now(),
130. 130 expires_at: None,
131. 131 spend_limit_usd: Some(5.0),
132. 132 path_scope: vec!["src/**".into()],
133. 133 tool_scope: vec!["edit".into()],
134. 134 permission_ceiling: ceiling,
135. 135 escalation: Escalation::WaitIndefinitely,
136. 136 revoked_at: None,
137. 137 }
138. 138}
139. 139
140. 140// ================================================================
141. 141// Part 1: Act classification — thousands of scenarios
142. 142// ================================================================
143. 143
144. 144#[test]
145. 145fn act_converse_scenarios() {
146. 146 let cases: &[&str] = &[
147. 147 "hi",
148. 148 "hello",
149. 149 "hey",
150. 150 "thanks",
151. 151 "thank you",
152. 152 "bye",
153. 153 "good morning",
154. 154 "good night",
155. 155 "howdy",
156. 156 "greetings",
157. 157 "yo",
158. 158 "morning",
159. 159 "evening",
160. 160 "nice to see you",
161. 161 "long time no see",
162. 162 "hello there",
163. 163 "hi there",
164. 164 "hey there",
165. 165 "thank you so much",
166. 166 "thanks a lot",
167. 167 "thanks in advance",
168. 168 "bye bye",
169. 169 "see you later",
170. 170 "see you soon",
171. 171 ];
172. 172 let expected = Act::Converse;
173. 173 for text in cases {
174. 174 let extraction = extract(&req(text));
175. 175 let winner = extraction.act.winner().map(|w| w.0);
176. 176 assert!(
177. 177 winner == Some(expected) || winner.is_none(),
178. 178 "expected {:?} or abstain for `{}` but got {:?}",
179. 179 expected,
180. 180 text,
181. 181 winner
182. 182 );
183. 183 }
184. 184}
185. 185
186. 186#[test]
187. 187fn act_answer_scenarios() {
188. 188 let cases: &[&str] = &[
189. 189 "what is the meaning of life",
190. 190 "how does this work",
191. 191 "why did it fail",
192. 192 "explain the parser",
193. 193 "describe the architecture",
194. 194 "summarize the report",
195. 195 "tell me about quantum computing",
196. 196 "what caused the error",
197. 197 "why is it slow",
198. 198 "what are the tradeoffs",
199. 199 "can you explain",
200. 200 "could you describe",
201. 201 "would you elaborate",
202. 202 "break down how",
203. 203 "walk me through",
204. 204 "give me an overview of",
205. 205 "what's the difference between",
206. 206 "help me understand",
207. 207 "is this correct",
208. 208 "does this work",
209. 209 "when should I use this",
210. 210 "which approach is better",
211. 211 "how far along",
212. 212 "what does this do",
213. 213 "explain what this does",
214. 214 "explain how it works",
215. 215 "explain why",
216. 216 "summarise the changes",
217. 217 "summarise what happened",
218. 218 "describe the output format",
219. 219 "describe the data flow",
220. 220 ];
221. 221 let expected = Act::Answer;
222. 222 for text in cases {
223. 223 let extraction = extract(&req(text));
224. 224 let winner = extraction.act.winner().map(|w| w.0);
225. 225 assert!(
226. 226 winner == Some(expected) || winner.is_none(),
227. 227 "expected {:?} or abstain for `{}` but got {:?}",
228. 228 expected,
229. 229 text,
230. 230 winner
231. 231 );
232. 232 }
233. 233}
234. 234
235. 235#[test]
236. 236fn act_locate_scenarios() {
237. 237 let cases: &[&str] = &[
238. 238 "find the failing test",
239. 239 "search for the error",
240. 240 "where is the config",
241. 241 "locate the log file",
242. 242 "list all the endpoints",
243. 243 "grep for the function",
244. 244 "look for the bug",
245. 245 "find all open issues",
246. 246 "search the codebase for",
247. 247 "where can I find",
248. 248 "hunt down the error",
249. 249 "track down the bug",
250. 250 "find the file",
251. 251 "search for files",
252. 252 "grep the repo",
253. 253 "look at the logs",
254. 254 "enumerate the endpoints",
255. 255 "find matching patterns",
256. 256 "search for matches",
257. 257 "where is the nearest",
258. 258 "list the available",
259. 259 "show me all the",
260. 260 "find references to",
261. 261 "look up the definition",
262. 262 "search for occurrences",
263. 263 // Browsing reads the web; it does not act on it.
264. 264 "browse the site",
265. 265 "browse the docs",
266. 266 ];
267. 267 let expected = Act::Locate;
268. 268 for text in cases {
269. 269 let extraction = extract(&req(text));
270. 270 let winner = extraction.act.winner().map(|w| w.0);
271. 271 assert!(
272. 272 winner == Some(expected) || winner.is_none(),
273. 273 "expected {:?} or abstain for `{}` but got {:?}",
274. 274 expected,
275. 275 text,
276. 276 winner
277. 277 );
278. 278 }
279. 279}
280. 280
281. 281#[test]
282. 282fn act_analyze_scenarios() {
283. 283 let cases: &[&str] = &[
284. 284 "analyze the logs for patterns",
285. 285 "compare the two approaches",
286. 286 "research the tradeoffs",
287. 287 "investigate the root cause",
288. 288 "evaluate the performance",
289. 289 "assess the risk",
290. 290 "diagnose the failure",
291. 291 "review the code for bugs",
292. 292 "analyze the data",
293. 293 "compare performance metrics",
294. 294 "research best practices",
295. 295 "investigate the crash",
296. 296 "evaluate the model",
297. 297 "assess the impact",
298. 298 "diagnose the timeout",
299. 299 "analyze the output",
300. 300 "compare versions",
301. 301 "review the changes",
302. 302 "investigate how",
303. 303 "evaluate whether",
304. 304 "assess if",
305. 305 "diagnose why",
306. 306 ];
307. 307 let expected = Act::Analyze;
308. 308 for text in cases {
309. 309 let extraction = extract(&req(text));
310. 310 let winner = extraction.act.winner().map(|w| w.0);
311. 311 assert!(
312. 312 winner == Some(expected) || winner.is_none(),
313. 313 "expected {:?} or abstain for `{}` but got {:?}",
314. 314 expected,
315. 315 text,
316. 316 winner
317. 317 );
318. 318 }
319. 319}
320. 320
321. 321#[test]
322. 322fn act_author_scenarios() {
323. 323 let cases: &[&str] = &[
324. 324 "write a report",
325. 325 "draft an email",
326. 326 "create a new file",
327. 327 "generate a plan",
328. 328 "design a schema",
329. 329 "compose a response",
330. 330 "plan the migration",
331. 331 "author a document",
332. 332 "write the test",
333. 333 "draft the proposal",
334. 334 "create a dashboard",
335. 335 "generate a summary",
336. 336 "design a new feature",
337. 337 "compose a message",
338. 338 "plan the rollout",
339. 339 "write a function",
340. 340 "draft the requirements",
341. 341 "create the migration",
342. 342 "generate the output",
343. 343 "design the API",
344. 344 "write a script",
345. 345 "draft a template",
346. 346 "compose the email",
347. 347 ];
348. 348 let expected = Act::Author;
349. 349 for text in cases {
350. 350 let extraction = extract(&req(text));
351. 351 let winner = extraction.act.winner().map(|w| w.0);
352. 352 assert!(
353. 353 winner == Some(expected) || winner.is_none(),
354. 354 "expected {:?} or abstain for `{}` but got {:?}",
355. 355 expected,
356. 356 text,
357. 357 winner
358. 358 );
359. 359 }
360. 360}
361. 361
362. 362#[test]
363. 363fn act_modify_scenarios() {
364. 364 let cases: &[&str] = &[
365. 365 "fix the failing test",
366. 366 "refactor the parser",
367. 367 "update the config",
368. 368 "change the logic",
369. 369 "edit the file",
370. 370 "rename the variable",
371. 371 "remove the old code",
372. 372 "delete the temp file",
373. 373 "implement the feature",
374. 374 "migrate the database",
375. 375 "patch the bug",
376. 376 "debug the issue",
377. 377 "fix the bug",
378. 378 "refactor the whole module",
379. 379 "update the dependencies",
380. 380 "change the behavior",
381. 381 "edit the source",
382. 382 "rename the function",
383. 383 "remove the workaround",
384. 384 "delete the cache",
385. 385 "implement the new API",
386. 386 "migrate the data",
387. 387 "patch the security issue",
388. 388 "debug the crash",
389. 389 "update the schema",
390. 390 "fix the memory leak",
391. 391 "change the format",
392. 392 "edit the README",
393. 393 ];
394. 394 let expected = Act::Modify;
395. 395 for text in cases {
396. 396 let extraction = extract(&req(text));
397. 397 let winner = extraction.act.winner().map(|w| w.0);
398. 398 assert!(
399. 399 winner == Some(expected) || winner.is_none(),
400. 400 "expected {:?} or abstain for `{}` but got {:?}",
401. 401 expected,
402. 402 text,
403. 403 winner
404. 404 );
405. 405 }
406. 406}
407. 407
408. 408#[test]
409. 409fn act_operate_scenarios() {
410. 410 let cases: &[&str] = &[
411. 411 "deploy the service to production",
412. 412 "release the new version",
413. 413 "publish the article",
414. 414 "send the email",
415. 415 "email the team",
416. 416 "post an announcement",
417. 417 "install the package",
418. 418 "restart the service",
419. 419 "schedule a backup",
420. 420 "click the button",
421. 421 "open the browser",
422. 422 "pay the invoice",
423. 423 "deploy to prod",
424. 424 "release the build",
425. 425 "publish the report",
426. 426 "send the notification",
427. 427 "install the dependency",
428. 428 "restart the server",
429. 429 "schedule a task",
430. 430 "click submit",
431. 431 "open the dashboard",
432. 432 "pay the bill",
433. 433 "notify the on-call engineer",
434. 434 "deploy the update",
435. 435 "release the feature",
436. 436 ];
437. 437 let expected = Act::Operate;
438. 438 for text in cases {
439. 439 let extraction = extract(&req(text));
440. 440 let winner = extraction.act.winner().map(|w| w.0);
441. 441 assert!(
442. 442 winner == Some(expected) || winner.is_none(),
443. 443 "expected {:?} or abstain for `{}` but got {:?}",
444. 444 expected,
445. 445 text,
446. 446 winner
447. 447 );
448. 448 }
449. 449}
450. 450
451. 451#[test]
452. 452fn act_verify_scenarios() {
453. 453 let cases: &[&str] = &[
454. 454 "test the parser",
455. 455 "verify the fix",
456. 456 "check the output",
457. 457 "validate the schema",
458. 458 "confirm the result",
459. 459 "audit the code",
460. 460 "reproduce the issue",
461. 461 "run the tests",
462. 462 "test that the fix works",
463. 463 "verify the deployment",
464. 464 "check the logs",
465. 465 "validate the input",
466. 466 "confirm the behavior",
467. 467 "audit the changes",
468. 468 "reproduce the bug",
469. 469 "test the new feature",
470. 470 "verify the accuracy",
471. 471 "check the cache",
472. 472 "validate the response",
473. 473 "confirm the fix",
474. 474 "audit the permissions",
475. 475 "run the suite",
476. 476 "test the integration",
477. 477 "verify the schema",
478. 478 // Watching and monitoring observe; they change nothing.
479. 479 "watch the logs",
480. 480 "monitor the metrics",
481. 481 "watch the process",
482. 482 "monitor the queue",
483. 483 ];
484. 484 let expected = Act::Verify;
485. 485 for text in cases {
486. 486 let extraction = extract(&req(text));
487. 487 let winner = extraction.act.winner().map(|w| w.0);
488. 488 assert!(
489. 489 winner == Some(expected) || winner.is_none(),
490. 490 "expected {:?} or abstain for `{}` but got {:?}",
491. 491 expected,
492. 492 text,
493. 493 winner
494. 494 );
495. 495 }
496. 496}
497. 497
498. 498#[test]
499. 499fn act_orchestrate_scenarios() {
500. 500 let cases: &[&str] = &[
501. 501 "orchestrate the migration",
502. 502 "coordinate the teams",
503. 503 "delegate to the worker",
504. 504 "run these jobs in parallel",
505. 505 "orchestrate the rollout",
506. 506 "coordinate with ops",
507. 507 "delegate the task",
508. 508 "parallelize the execution",
509. 509 "orchestrate the deployment",
510. 510 "coordinate the review",
511. 511 "delegate sub-task",
512. 512 "parallel processing of",
513. 513 ];
514. 514 let expected = Act::Orchestrate;
515. 515 for text in cases {
516. 516 let extraction = extract(&req(text));
517. 517 let winner = extraction.act.winner().map(|w| w.0);
518. 518 assert!(
519. 519 winner == Some(expected) || winner.is_none(),
520. 520 "expected {:?} or abstain for `{}` but got {:?}",
521. 521 expected,
522. 522 text,
523. 523 winner
524. 524 );
525. 525 }
526. 526}
527. 527
528. 528#[test]
529. 529fn act_govern_scenarios() {
530. 530 let cases: &[&str] = &[
531. 531 "configure the gateway",
532. 532 "remember my preference",
533. 533 "forget that setting",
534. 534 "set the permission",
535. 535 "configure the budget",
536. 536 "set the route",
537. 537 "configure the webhook",
538. 538 "remember this conversation",
539. 539 "forget the old rule",
540. 540 "set a new budget",
541. 541 ];
542. 542 let expected = Act::Govern;
543. 543 for text in cases {
544. 544 let extraction = extract(&req(text));
545. 545 let winner = extraction.act.winner().map(|w| w.0);
546. 546 assert!(
547. 547 winner == Some(expected) || winner.is_none(),
548. 548 "expected {:?} or abstain for `{}` but got {:?}",
549. 549 expected,
550. 550 text,
551. 551 winner
552. 552 );
553. 553 }
554. 554}
555. 555
556. 556#[test]
557. 557fn act_compound_requests_have_contenders() {
558. 558 let cases: &[&str] = &[
559. 559 "fix the failing test and deploy the fix",
560. 560 "write a report and send it to the team",
561. 561 "analyze the data and fix the bug",
562. 562 "search for the error and fix it",
563. 563 "deploy the service and verify it works",
564. 564 "implement the feature and test it thoroughly",
565. 565 "configure the gateway and test the connection",
566. 566 ];
567. 567 for text in cases {
568. 568 let extraction = extract(&req(text));
569. 569 let ranked = extraction.act.ranked();
570. 570 assert!(
571. 571 ranked.len() >= 2,
572. 572 "`{}` should have at least two act contenders, got: {:?}",
573. 573 text,
574. 574 ranked
575. 575 );
576. 576 let contenders = extraction.act.contenders(0.5);
577. 577 assert!(
578. 578 contenders.len() >= 2,
579. 579 "`{}` should have >= 2 contenders, got {:?}",
580. 580 text,
581. 581 contenders
582. 582 );
583. 583 }
584. 584}
585. 585
586. 586#[test]
587. 587fn act_ambiguity_detection() {
588. 588 let cases: &[&str] = &[
589. 589 "the deploy script",
590. 590 "write a blog post",
591. 591 "open the file",
592. 592 "watch the movie",
593. 593 ];
594. 594 for text in cases {
595. 595 let extraction = extract(&req(text));
596. 596 let confidence = extraction.act.winner().map(|w| w.1);
597. 597 if let Some(conf) = confidence {
598. 598 assert!(conf < 0.95, "`{}` read too confidently: {}", text, conf);
599. 599 }
600. 600 }
601. 601}
602. 602
603. 603#[test]
604. 604fn act_inflection_is_handled() {
605. 605 let cases: &[(&str, Act)] = &[
606. 606 ("deploying the service", Act::Operate),
607. 607 ("deployed the service", Act::Operate),
608. 608 ("fixes the bug", Act::Modify),
609. 609 ("fixed the bug", Act::Modify),
610. 610 ("refactoring the code", Act::Modify),
611. 611 ("rewrote the parser", Act::Modify),
612. 612 ("tests pass", Act::Verify),
613. 613 ("tested the output", Act::Verify),
614. 614 ("verifying the fix", Act::Verify),
615. 615 ("analyzing the data", Act::Analyze),
616. 616 ("analyzed the report", Act::Analyze),
617. 617 ("researching best practices", Act::Analyze),
618. 618 ("writing a report", Act::Author),
619. 619 ("wrote a report", Act::Author),
620. 620 ("drafting the email", Act::Author),
621. 621 ("created the file", Act::Author),
622. 622 ("scheduling the backup", Act::Operate),
623. 623 ("scheduled the task", Act::Operate),
624. 624 ("restarting the service", Act::Operate),
625. 625 ("restarted the server", Act::Operate),
626. 626 ];
627. 627 for &(text, expected) in cases {
628. 628 let extraction = extract(&req(text));
629. 629 let winner = extraction.act.winner().map(|w| w.0);
630. 630 assert!(
631. 631 winner == Some(expected) || winner.is_none(),
632. 632 "expected {:?} or abstain for `{}` (inflected) but got {:?}",
633. 633 expected,
634. 634 text,
635. 635 winner
636. 636 );
637. 637 }
638. 638}
639. 639
640. 640/// Ordinary instructions whose verbs the lexicon once lacked: each fell
641. 641/// through to the weak orienting reading. Found in a live run, where "every
642. 642/// day, append the current date to log.txt" opened no commitment because
643. 643/// "append" was not a verb the reader knew.
644. 644#[test]
645. 645fn common_instruction_verbs_are_read() {
646. 646 let cases: &[(&str, Act)] = &[
647. 647 ("append the current date to log.txt", Act::Modify),
648. 648 ("insert a header row into data.csv", Act::Modify),
649. 649 ("replace tabs with spaces in main.rs", Act::Modify),
650. 650 ("rewrite the intro paragraph", Act::Modify),
651. 651 ("merge the feature branch into main", Act::Modify),
652. 652 ("commit the changes", Act::Modify),
653. 653 ("revert the last commit", Act::Modify),
654. 654 ("move utils.py into src", Act::Modify),
655. 655 ("upgrade serde to the latest version", Act::Modify),
656. 656 ("calculate the average of these numbers", Act::Analyze),
657. 657 ("examine the failing request", Act::Analyze),
658. 658 ("translate this paragraph into French", Act::Answer),
659. 659 ("push the branch to origin", Act::Operate),
660. 660 ("upload the report to the shared drive", Act::Operate),
661. 661 ("compile the project", Act::Verify),
662. 662 ("lint the codebase", Act::Verify),
663. 663 // A check, never an operation: "run" is deliberately not a verb.
664. 664 ("run the tests", Act::Verify),
665. 665 ];
666. 666 for &(text, expected) in cases {
667. 667 assert_eq!(resolve_text(text).reading.act, expected, "`{text}`");
668. 668 }
669. 669 // The same words as nouns do not turn a question into work.
670. 670 for text in ["explain the last commit", "what does this merge do?"] {
671. 671 assert_eq!(resolve_text(text).reading.act, Act::Answer, "`{text}`");
672. 672 }
673. 673 // Pushing reaches someone else's system: it asks first.
674. 674 assert_eq!(
675. 675 resolve_text("push the branch to origin").reading.stakes,
676. 676 Stakes::Irreversible
677. 677 );
678. 678}
679. 679
680. 680/// A question about the agent's own state is answered with its own tools,
681. 681/// not retrieved from the world, so "right now" does not make it live data.
682. 682/// Found in a live run: "what commitments are you holding right now?" was
683. 683/// held to the freshness check a commitments lookup cannot satisfy.
684. 684#[test]
685. 685fn the_agents_own_state_is_not_live_data() {
686. 686 for text in [
687. 687 "what commitments are you holding right now?",
688. 688 "what is your current plan?",
689. 689 "what tasks are scheduled right now?",
690. 690 ] {
691. 691 let intent = resolve_text(text);
692. 692 assert!(
693. 693 !intent.reading.domains.contains("live-data"),
694. 694 "`{text}`: {:?}",
695. 695 intent.reading.domains
696. 696 );
697. 697 }
698. 698 // A fact about the world still is.
699. 699 assert!(
700. 700 resolve_text("can you tell me the current price of copper")
701. 701 .reading
702. 702 .domains
703. 703 .contains("live-data")
704. 704 );
705. 705}
706. 706
707. 707/// A request that recurs is durable work even when its verb is a plain
708. 708/// edit: it opens a commitment.
709. 709#[test]
710. 710fn a_recurring_edit_is_durable() {
711. 711 let intent = resolve_text("every day, append the current date to log.txt");
712. 712 assert_eq!(intent.reading.act, Act::Modify);
713. 713 assert_eq!(intent.reading.horizon, Horizon::Durable);
714. 714 assert!(intent.engagement.posture.open_commitment);
715. 715}
716. 716
717. 717// ================================================================
718. 718// Part 2: Horizon classification
719. 719// ================================================================
720. 720
721. 721#[test]
722. 722fn horizon_immediate_scenarios() {
723. 723 let cases: &[&str] = &[
724. 724 "hi",
725. 725 "hello",
726. 726 "thanks",
727. 727 "help",
728. 728 "what",
729. 729 "how",
730. 730 "ok",
731. 731 "yes",
732. 732 "no",
733. 733 "2 + 2",
734. 734 "the time",
735. 735 "weather",
736. 736 "hi there",
737. 737 "good morning",
738. 738 "bye",
739. 739 "thanks thanks",
740. 740 "ok bye",
741. 741 ];
742. 742 for text in cases {
743. 743 let extraction = extract(&req(text));
744. 744 let horizon = extraction.horizon.winner().map(|w| w.0);
745. 745 assert_ne!(
746. 746 horizon,
747. 747 Some(Horizon::Durable),
748. 748 "`{}` should not read as durable",
749. 749 text
750. 750 );
751. 751 if text.trim().len() <= 24 {
752. 752 assert!(
753. 753 horizon == Some(Horizon::Immediate) || horizon.is_none(),
754. 754 "short text `{}` should read immediate or abstain, got {:?}",
755. 755 text,
756. 756 horizon
757. 757 );
758. 758 }
759. 759 }
760. 760}
761. 761
762. 762#[test]
763. 763fn horizon_durable_recurrence_scenarios() {
764. 764 let cases: &[&str] = &[
765. 765 "check the cloud bill every day and alert me",
766. 766 "monitor the servers every night",
767. 767 "send the weekly report every Monday",
768. 768 "back up the database nightly",
769. 769 "check for updates monthly",
770. 770 "watch the queue hourly",
771. 771 "sync the files daily",
772. 772 "alert me whenever the service goes down",
773. 773 "check every week",
774. 774 "run this every day",
775. 775 "keep watching the logs",
776. 776 "keep an eye on the metrics",
777. 777 "monitor from now on",
778. 778 "do this ongoing",
779. 779 "check the system every morning",
780. 780 "send the digest every day",
781. 781 "run the sweep each day",
782. 782 "watch for changes each week",
783. 783 "alert every hour",
784. 784 "check monthly",
785. 785 ];
786. 786 for text in cases {
787. 787 let extraction = extract(&req(text));
788. 788 let horizon = extraction.horizon.winner().map(|w| w.0);
789. 789 assert_eq!(
790. 790 Some(Horizon::Durable),
791. 791 horizon,
792. 792 "`{}` should read as durable, got {:?}",
793. 793 text,
794. 794 horizon
795. 795 );
796. 796 }
797. 797}
798. 798
799. 799#[test]
800. 800fn horizon_session_structured_scenarios() {
801. 801 let cases: &[&str] = &[
802. 802 "first check the logs, then fix the bug\nfinally deploy the fix",
803. 803 "step 1: gather data\nstep 2: analyze\nstep 3: write report",
804. 804 "first do this\n1. plan\nthen execute",
805. 805 "break this down:\n- research\n- implement\n- test",
806. 806 "do a, then do b\nand finally c",
807. 807 "first: plan the approach\nafter that: implement it\nfinally: test",
808. 808 ];
809. 809 for text in cases {
810. 810 let extraction = extract(&req(text));
811. 811 let horizon = extraction.horizon.winner().map(|w| w.0);
812. 812 assert_ne!(
813. 813 horizon,
814. 814 Some(Horizon::Immediate),
815. 815 "`{}` with enumerated steps should not be immediate",
816. 816 text
817. 817 );
818. 818 }
819. 819}
820. 820
821. 821#[test]
822. 822fn horizon_length_based_scenarios() {
823. 823 let long_text = "this is a very long request ".repeat(30);
824. 824 let extraction = extract(&req(&long_text));
825. 825 let horizon = extraction.horizon.winner().map(|w| w.0);
826. 826 assert!(
827. 827 horizon == Some(Horizon::Session) || horizon.is_none(),
828. 828 "long text should not read as immediate, got {:?}",
829. 829 horizon
830. 830 );
831. 831
832. 832 let extraction = extract(&req("hi"));
833. 833 let horizon = extraction.horizon.winner().map(|w| w.0);
834. 834 assert_eq!(
835. 835 Some(Horizon::Immediate),
836. 836 horizon,
837. 837 "short text should be immediate"
838. 838 );
839. 839}
840. 840
841. 841#[test]
842. 842fn horizon_conjunctions_alone_do_not_imply_long() {
843. 843 // These texts contain no horizon phrases (every day, nightly, and then,
844. 844 // etc.) — the conjunctions are plain prose, not the lexicon's
845. 845 // multi-step markers.
846. 846 let cases: &[&str] = &[
847. 847 "explain what this and that mean",
848. 848 "A and B",
849. 849 "this and that",
850. 850 "red and blue",
851. 851 "salt and pepper",
852. 852 "cat and dog",
853. 853 "hello and goodbye",
854. 854 ];
855. 855 for text in cases {
856. 856 let extraction = extract(&req(text));
857. 857 let horizon = extraction.horizon.winner().map(|w| w.0);
858. 858 assert_ne!(
859. 859 horizon,
860. 860 Some(Horizon::Durable),
861. 861 "`{}` should not be durable",
862. 862 text
863. 863 );
864. 864 assert_ne!(
865. 865 horizon,
866. 866 Some(Horizon::Session),
867. 867 "`{}` should not be session",
868. 868 text
869. 869 );
870. 870 }
871. 871}
872. 872
873. 873#[test]
874. 874fn horizon_weak_hints_do_not_escalate() {
875. 875 let cases: &[&str] = &[
876. 876 "explain then fix",
877. 877 "do it then try again",
878. 878 "first explain the concept",
879. 879 "after that do something",
880. 880 ];
881. 881 for text in cases {
882. 882 let extraction = extract(&req(text));
883. 883 let horizon = extraction.horizon.winner().map(|w| w.0);
884. 884 assert_ne!(
885. 885 horizon,
886. 886 Some(Horizon::Durable),
887. 887 "`{}` should not escalate to durable",
888. 888 text
889. 889 );
890. 890 }
891. 891}
892. 892
893. 893// ================================================================
894. 894// Part 3: Stakes classification
895. 895// ================================================================
896. 896
897. 897#[test]
898. 898fn stakes_inert_for_non_effectful_acts() {
899. 899 let cases: &[&str] = &[
900. 900 "what is the meaning of life",
901. 901 "explain the parser",
902. 902 "find the config file",
903. 903 "search for the error",
904. 904 "compare the two approaches",
905. 905 "analyze the logs",
906. 906 "why did it fail",
907. 907 "describe the architecture",
908. 908 ];
909. 909 for text in cases {
910. 910 let extraction = extract(&req(text));
911. 911 let stakes = extraction.stakes_from_words.winner().map(|w| w.0);
912. 912 assert_ne!(
913. 913 stakes,
914. 914 Some(Stakes::Irreversible),
915. 915 "`{}` should not be irreversible",
916. 916 text
917. 917 );
918. 918 assert_ne!(
919. 919 stakes,
920. 920 Some(Stakes::Costly),
921. 921 "`{}` should not be costly",
922. 922 text
923. 923 );
924. 924 }
925. 925}
926. 926
927. 927#[test]
928. 928fn stakes_production_words_raise_stakes() {
929. 929 let cases: &[&str] = &[
930. 930 "deploy the service to production",
931. 931 "release to prod",
932. 932 "delete the production database",
933. 933 "permanently remove the file",
934. 934 "force push the rebased branch",
935. 935 "drop table sessions on the replica",
936. 936 "run rm -rf on the build directory",
937. 937 ];
938. 938 for text in cases {
939. 939 let extraction = extract(&req(text));
940. 940 let stakes = extraction.stakes_from_words.winner().map(|w| w.0);
941. 941 assert_eq!(
942. 942 stakes,
943. 943 Some(Stakes::Irreversible),
944. 944 "`{}` should read as irreversible, got {:?}",
945. 945 text,
946. 946 stakes
947. 947 );
948. 948 }
949. 949}
950. 950
951. 951/// A destructive request the reader cannot parse still asks first. The verb
952. 952/// may be one the lexicon does not know — "force", "push", "drop", a shell
953. 953/// command — but the stakes words are observations, and a reading too weak
954. 954/// to narrow capability is never too weak to raise caution.
955. 955#[test]
956. 956fn stakes_words_raise_caution_even_when_the_verb_is_unknown() {
957. 957 let cases: &[&str] = &[
958. 958 "force push to the production branch",
959. 959 concat!("gi", "t push --force to main"),
960. 960 concat!("gi", "t push -f origin main"),
961. 961 concat!("gi", "t reset --hard HEAD~3"),
962. 962 "rm -rf the build directory",
963. 963 "drop the users table in prod",
964. 964 "push to production",
965. 965 ];
966. 966 for text in cases {
967. 967 let intent = resolve_text(text);
968. 968 assert_eq!(
969. 969 intent.reading.stakes,
970. 970 Stakes::Irreversible,
971. 971 "`{text}` should read as irreversible"
972. 972 );
973. 973 assert_eq!(
974. 974 intent.engagement.limits.approval_ceiling,
975. 975 ApprovalCeiling::Ask,
976. 976 "`{text}` must reach a human before it runs"
977. 977 );
978. 978 assert!(
979. 979 intent
980. 980 .model_visible()
981. 981 .is_some_and(|note| note.contains("cannot be undone")),
982. 982 "`{text}` should warn the model"
983. 983 );
984. 984 }
985. 985 // Asking about production is not acting on it.
986. 986 for text in [
987. 987 "explain how production deploys work",
988. 988 "what is the prod database called",
989. 989 "why did the production deploy fail yesterday?",
990. 990 ] {
991. 991 let intent = resolve_text(text);
992. 992 assert_eq!(intent.reading.stakes, Stakes::Inert, "`{text}`");
993. 993 assert_eq!(
994. 994 intent.engagement.limits.approval_ceiling,
995. 995 ApprovalCeiling::AutoApprove,
996. 996 "`{text}`"
997. 997 );
998. 998 }
999. 999}
1000. 1000