1313. 1313 let (log, _, t2, _) = two_closed_one_open(dir.path());
1314. 1314 let index = TurnIndex::from_log(&log);
1315. 1315 let turn2 = index.turn_by_id(&t2).unwrap();
1316. 1316 let card = turn2.build_card("completed", "Here is what I found.".to_string(), &|s| {
1317. 1317 s.len() as u64 / 4
1318. 1318 });
1319. 1319 let line = card.line(2);
1320. 1320 assert!(line.starts_with("#2 asked:"));
1321. 1321 assert!(line.contains("did: search"));
1322. 1322 assert!(line.contains("research.synthesis"));
1323. 1323 assert!(line.contains("Rust news"));
1324. 1324 assert!(line.contains("ev:call-1"));
1325. 1325 }
1326. 1326
1327. 1327 #[test]
1328. 1328 fn digest_per_shape() {
1329. 1329 let search_ev = Evidence {
1330. 1330 tool: "search".into(),
1331. 1331 input: serde_json::json!({}),
1332. 1332 content: r#"[{"title":"A","url":"https://a"},{"title":"B","url":"https://b"}]"#.into(),
1333. 1333 is_error: false,
1334. 1334 };
1335. 1335 let digest = evidence_digest("ev1", &search_ev);
1336. 1336 assert!(digest.contains("https://a"));
1337. 1337 assert!(digest.contains("https://b"));
1338. 1338 assert!(digest.ends_with("[evidence:ev1 \u{2014} 65 chars; call recall to expand]"));
1339. 1339
1340. 1340 let bash_ev = Evidence {
1341. 1341 tool: "bash".into(),
1342. 1342 input: serde_json::json!({"command": "echo hi"}),
1343. 1343 content: "hi\nexit code: 0".into(),
1344. 1344 is_error: false,
1345. 1345 };
1346. 1346 let bash_digest_text = evidence_digest("ev2", &bash_ev);
1347. 1347 assert!(bash_digest_text.contains("exit code: 0"));
1348. 1348
1349. 1349 let text_ev = Evidence {
1350. 1350 tool: "read".into(),
1351. 1351 input: serde_json::json!({}),
1352. 1352 content: "# Heading\n\nFirst paragraph text.\n\nMore.".into(),
1353. 1353 is_error: false,
1354. 1354 };
1355. 1355 let text_digest_text = evidence_digest("ev3", &text_ev);
1356. 1356 assert!(text_digest_text.contains("# Heading"));
1357. 1357 assert!(text_digest_text.contains("First paragraph text."));
1358. 1358
1359. 1359 let err_ev = Evidence {
1360. 1360 tool: "bash".into(),
1361. 1361 input: serde_json::json!({}),
1362. 1362 content: "boom: permission denied".into(),
1363. 1363 is_error: true,
1364. 1364 };
1365. 1365 let err_digest = evidence_digest("ev4", &err_ev);
1366. 1366 assert!(err_digest.starts_with("boom: permission denied"));
1367. 1367 }
1368. 1368
1369. 1369 #[test]
1370. 1370 fn bm25_returns_the_matching_turn_first() {
1371. 1371 let dir = tempfile::tempdir().unwrap();
1372. 1372 let (mut log, _, t2, _) = two_closed_one_open(dir.path());
1373. 1373 let card = TurnIndex::from_log(&log)
1374. 1374 .turn_by_id(&t2)
1375. 1375 .unwrap()
1376. 1376 .build_card("completed", "Here is what I found.".to_string(), &|s| {
1377. 1377 s.len() as u64 / 4
1378. 1378 });
1379. 1379 log.append_turn_card(TurnCardRecord {
1380. 1380 turn_id: t2.clone(),
1381. 1381 card,
1382. 1382 })
1383. 1383 .unwrap();
1384. 1384 let index = TurnIndex::from_log(&log);
1385. 1385 let hits = index.search("rust news");
1386. 1386 assert!(!hits.is_empty());
1387. 1387 assert_eq!(hits[0].0, t2);
1388. 1388 }
1389. 1389
1390. 1390 #[test]
1391. 1391 fn control_messages_are_not_turns_or_steps() {
1392. 1392 let dir = tempfile::tempdir().unwrap();
1393. 1393 let mut log = open_log(dir.path());
1394. 1394 let t1 = log.append_message(user_text("do a thing")).unwrap().id;
1395. 1395 log.append_message(assistant_tool_call(
1396. 1396 "c1",
1397. 1397 "bash",
1398. 1398 serde_json::json!({"command": "ls"}),
1399. 1399 ))
1400. 1400 .unwrap();
1401. 1401 log.append_message(tool_result("c1", "ok")).unwrap();
1402. 1402 log.append_message(MessageRecord::control(
1403. 1403 vak_intent::control::ControlKind::StopHook,
1404. 1404 "[stop-hook]: keep going",
1405. 1405 ))
1406. 1406 .unwrap();
1407. 1407 log.append_message(assistant_text("done")).unwrap();
1408. 1408 let index = TurnIndex::from_log(&log);
1409. 1409 assert_eq!(index.turns.len(), 1);
1410. 1410 let turn = index.turn_by_id(&t1).unwrap();
1411. 1411 assert_eq!(turn.steps.len(), 1, "the nudge must not become a step");
1412. 1412 assert!(turn.closed);
1413. 1413 }
1414. 1414
1415. 1415 /// A gate that redoes a text-only draft appends a control nudge AFTER
1416. 1416 /// it without any further assistant reply yet: the turn must stay open
1417. 1417 /// (never rendered as a closed `full_record`, which would drop the
1418. 1418 /// nudge entirely) and `current_verbatim` must end with the nudge, so
1419. 1419 /// the next request's last message is a real user-role message rather
1420. 1420 /// than the assistant's own draft (invariant: current Claude models
1421. 1421 /// reject a request with no trailing user turn).
1422. 1422 #[test]
1423. 1423 fn a_draft_followed_by_a_control_nudge_with_no_reply_yet_stays_open() {
1424. 1424 let dir = tempfile::tempdir().unwrap();
1425. 1425 let mut log = open_log(dir.path());
1426. 1426 let t1 = log.append_message(user_text("do a thing")).unwrap().id;
1427. 1427 log.append_message(assistant_text("draft answer")).unwrap();
1428. 1428 log.append_message(MessageRecord::control(
1429. 1429 vak_intent::control::ControlKind::StopHook,
1430. 1430 "[stop-hook]: keep going",
1431. 1431 ))
1432. 1432 .unwrap();
1433. 1433 let index = TurnIndex::from_log(&log);
1434. 1434 assert_eq!(index.turns.len(), 1);
1435. 1435 let turn = index.turn_by_id(&t1).unwrap();
1436. 1436 assert!(
1437. 1437 !turn.closed,
1438. 1438 "a nudge with no reply after it must keep the turn open"
1439. 1439 );
1440. 1440 let verbatim = turn.current_verbatim();
1441. 1441 let last = verbatim.last().expect("at least the directive");
1442. 1442 assert_eq!(
1443. 1443 last.text_content(),
1444. 1444 "[stop-hook]: keep going",
1445. 1445 "the nudge must be the last message so it reaches the model"
1446. 1446 );
1447. 1447 assert_eq!(last.role, R::User);
1448. 1448 }
1449. 1449
1450. 1450 /// The same shape, but a tool result (rather than a nudge) is the last
1451. 1451 /// thing appended after the draft: also open, for the same reason.
1452. 1452 #[test]
1453. 1453 fn a_draft_followed_by_a_tool_result_with_no_reply_yet_stays_open() {
1454. 1454 let dir = tempfile::tempdir().unwrap();
1455. 1455 let mut log = open_log(dir.path());
1456. 1456 let t1 = log.append_message(user_text("do a thing")).unwrap().id;
1457. 1457 log.append_message(assistant_tool_call(
1458. 1458 "c1",
1459. 1459 "bash",
1460. 1460 serde_json::json!({"command": "ls"}),
1461. 1461 ))
1462. 1462 .unwrap();
1463. 1463 log.append_message(tool_result("c1", "ok")).unwrap();
1464. 1464 let index = TurnIndex::from_log(&log);
1465. 1465 let turn = index.turn_by_id(&t1).unwrap();
1466. 1466 assert!(!turn.closed, "a fresh tool result must keep the turn open");
1467. 1467 }
1468. 1468
1469. 1469 #[test]
1470. 1470 fn intent_reading_attaches_to_its_turn() {
1471. 1471 let dir = tempfile::tempdir().unwrap();
1472. 1472 let mut log = open_log(dir.path());
1473. 1473 let t1 = log
1474. 1474 .append_message(user_text("find the weather"))
1475. 1475 .unwrap()
1476. 1476 .id;
1477. 1477 let reading = vak_intent::Reading::general();
1478. 1478 log.append_intent(IntentRecord {
1479. 1479 reading,
1480. 1480 engagement: vak_intent::Engagement::general(),
1481. 1481 provenance: vak_intent::Provenance::new(vak_intent::Tier::General, 1, Vec::new()),
1482. 1482 outcome: None,
1483. 1483 model_visible: None,
1484. 1484 commitment_id: None,
1485. 1485 strands: Vec::new(),
1486. 1486 strand_commitments: Default::default(),
1487. 1487 })
1488. 1488 .unwrap();
1489. 1489 log.append_message(assistant_text("it is sunny")).unwrap();
1490. 1490 let index = TurnIndex::from_log(&log);
1491. 1491 let turn = index.turn_by_id(&t1).unwrap();
1492. 1492 let card = turn.build_card("completed", "it is sunny".to_string(), &|s| {
1493. 1493 s.len() as u64 / 4
1494. 1494 });
1495. 1495 assert_eq!(card.reading.act, "answer");
1496. 1496 }
1497. 1497
1498. 1498 #[test]
1499. 1499 fn every_ledger_activity_entry_is_ignored_by_turn_structure() {
1500. 1500 let dir = tempfile::tempdir().unwrap();
1501. 1501 let mut log = open_log(dir.path());
1502. 1502 log.append_message(user_text("hi")).unwrap();
1503. 1503 log.append_activity(ActivityRecord {
1504. 1504 activity_id: "a1".into(),
1505. 1505 turn: None,
1506. 1506 kind: ActivityKind::Diagnostic,
1507. 1507 status: ActivityStatus::Succeeded,
1508. 1508 label: "note".into(),
1509. 1509 detail: None,
1510. 1510 data: Default::default(),
1511. 1511 })
1512. 1512 .unwrap();
1513. 1513 log.append_message(assistant_text("hello")).unwrap();
1514. 1514 let index = TurnIndex::from_log(&log);
1515. 1515 assert_eq!(index.turns.len(), 1);
1516. 1516 }
1517. 1517
1518. 1518 #[test]
1519. 1519 fn packets_collect_compaction_entries() {
1520. 1520 let dir = tempfile::tempdir().unwrap();
1521. 1521 let mut log = open_log(dir.path());
1522. 1522 let t1 = log.append_message(user_text("first")).unwrap().id;
1523. 1523 log.append_message(assistant_text("first answer")).unwrap();
1524. 1524 log.append(Entry::new(
1525. 1525 log.tail_id().cloned(),
1526. 1526 EntryPayload::Compaction(CompactionEntry {
1527. 1527 summary: "summary text".into(),
1528. 1528 first_turn_id: t1.clone(),
1529. 1529 last_turn_id: t1,
1530. 1530 model: "fixture-model".into(),
1531. 1531 tokens_before: 100,
1532. 1532 reset_all: false,
1533. 1533 }),
1534. 1534 ))
1535. 1535 .unwrap();
1536. 1536 let index = TurnIndex::from_log(&log);
1537. 1537 assert_eq!(index.packets.len(), 1);
1538. 1538 assert_eq!(index.packets[0].summary, "summary text");
1539. 1539 }
1540. 1540}
1541. 1541