1455. 1455 // While the condition is false the pass costs nothing and changes
1456. 1456 // nothing — this is the zero-token watch path.
1457. 1457 let report = maintain(dir.path()).await;
1458. 1458 assert!(report.satisfied.is_empty());
1459. 1459 assert_eq!(
1460. 1460 ledger.get(&handle.commitment_id).unwrap().unwrap().phase,
1461. 1461 vak_commit::Phase::Suspended
1462. 1462 );
1463. 1463
1464. 1464 std::fs::write(dir.path().join("report.csv"), "done").unwrap();
1465. 1465 let report = maintain(dir.path()).await;
1466. 1466 assert_eq!(report.satisfied, vec![handle.commitment_id.clone()]);
1467. 1467 assert_ne!(
1468. 1468 ledger.get(&handle.commitment_id).unwrap().unwrap().phase,
1469. 1469 vak_commit::Phase::Suspended
1470. 1470 );
1471. 1471 }
1472. 1472
1473. 1473 #[tokio::test]
1474. 1474 async fn a_commitment_dependency_wakes_after_fulfillment() {
1475. 1475 let dir = tempfile::tempdir().unwrap();
1476. 1476 let ledger = CommitmentLedger::new(dir.path());
1477. 1477 let dependency = ledger
1478. 1478 .open_commitment(vak_commit::spec_from_reading(
1479. 1479 "dependency",
1480. 1480 Reading::general(),
1481. 1481 Vec::new(),
1482. 1482 dir.path().to_path_buf(),
1483. 1483 Economics::default(),
1484. 1484 ))
1485. 1485 .unwrap();
1486. 1486 ledger
1487. 1487 .append(&Event::new(
1488. 1488 &dependency,
1489. 1489 EventKind::Closed {
1490. 1490 verdict: Verdict::Fulfilled,
1491. 1491 strength: Satisfaction::Asserted,
1492. 1492 evidence: Vec::new(),
1493. 1493 note: "done".into(),
1494. 1494 },
1495. 1495 ))
1496. 1496 .unwrap();
1497. 1497 let waiting = ledger
1498. 1498 .open_commitment(vak_commit::spec_from_reading(
1499. 1499 "waiting",
1500. 1500 Reading::general(),
1501. 1501 Vec::new(),
1502. 1502 dir.path().to_path_buf(),
1503. 1503 Economics::default(),
1504. 1504 ))
1505. 1505 .unwrap();
1506. 1506 ledger
1507. 1507 .append(&Event::new(
1508. 1508 &waiting,
1509. 1509 EventKind::Suspended {
1510. 1510 suspension: vak_commit::Suspension::Commitment {
1511. 1511 commitment_id: dependency,
1512. 1512 },
1513. 1513 },
1514. 1514 ))
1515. 1515 .unwrap();
1516. 1516 let report = maintain(dir.path()).await;
1517. 1517 assert_eq!(report.resumed, vec![waiting]);
1518. 1518 }
1519. 1519
1520. 1520 #[tokio::test]
1521. 1521 async fn a_scheduled_suspension_wakes_once_its_time_arrives() {
1522. 1522 let dir = tempfile::tempdir().unwrap();
1523. 1523 let ledger = CommitmentLedger::new(dir.path());
1524. 1524 let handle = begin_episode(
1525. 1525 dir.path(),
1526. 1526 &config(),
1527. 1527 &intent_with(Evidence::None, Horizon::Durable, 0.9),
1528. 1528 "check the bill every day",
1529. 1529 "s1",
1530. 1530 dir.path(),
1531. 1531 )
1532. 1532 .unwrap();
1533. 1533 ledger
1534. 1534 .append(&Event::new(
1535. 1535 &handle.commitment_id,
1536. 1536 EventKind::Suspended {
1537. 1537 suspension: vak_commit::Suspension::Schedule {
1538. 1538 at: Some(chrono::Utc::now() + chrono::Duration::hours(2)),
1539. 1539 cron: None,
1540. 1540 },
1541. 1541 },
1542. 1542 ))
1543. 1543 .unwrap();
1544. 1544 assert!(maintain(dir.path()).await.resumed.is_empty());
1545. 1545
1546. 1546 ledger
1547. 1547 .append(&Event::new(
1548. 1548 &handle.commitment_id,
1549. 1549 EventKind::Suspended {
1550. 1550 suspension: vak_commit::Suspension::Schedule {
1551. 1551 at: Some(chrono::Utc::now() - chrono::Duration::minutes(1)),
1552. 1552 cron: None,
1553. 1553 },
1554. 1554 },
1555. 1555 ))
1556. 1556 .unwrap();
1557. 1557 assert_eq!(
1558. 1558 maintain(dir.path()).await.resumed,
1559. 1559 vec![handle.commitment_id]
1560. 1560 );
1561. 1561 }
1562. 1562
1563. 1563 /// A question with no policy waits forever by design. That is a decision,
1564. 1564 /// not a leak — and it must not quietly become an assumption.
1565. 1565 #[tokio::test]
1566. 1566 async fn an_unanswered_question_waits_unless_a_policy_says_otherwise() {
1567. 1567 let dir = tempfile::tempdir().unwrap();
1568. 1568 let ledger = CommitmentLedger::new(dir.path());
1569. 1569 let handle = begin_episode(
1570. 1570 dir.path(),
1571. 1571 &config(),
1572. 1572 &intent_with(Evidence::None, Horizon::Durable, 0.9),
1573. 1573 "migrate the schema every night",
1574. 1574 "s1",
1575. 1575 dir.path(),
1576. 1576 )
1577. 1577 .unwrap();
1578. 1578 defer_for_human(
1579. 1579 dir.path(),
1580. 1580 &handle.commitment_id,
1581. 1581 "which database?",
1582. 1582 None,
1583. 1583 vak_intent::Escalation::WaitIndefinitely,
1584. 1584 )
1585. 1585 .unwrap();
1586. 1586 assert!(maintain(dir.path()).await.escalated.is_empty());
1587. 1587 assert_eq!(
1588. 1588 ledger.get(&handle.commitment_id).unwrap().unwrap().phase,
1589. 1589 vak_commit::Phase::Suspended
1590. 1590 );
1591. 1591 }
1592. 1592
1593. 1593 #[test]
1594. 1594 fn expiry_closes_explicitly_and_budget_exhaustion_does_not() {
1595. 1595 let dir = tempfile::tempdir().unwrap();
1596. 1596 let ledger = CommitmentLedger::new(dir.path());
1597. 1597 let mut config = config();
1598. 1598 config.commitment.default_ttl_days = Some(1);
1599. 1599
1600. 1600 let handle = begin_episode(
1601. 1601 dir.path(),
1602. 1602 &config,
1603. 1603 &intent_with(Evidence::None, Horizon::Durable, 0.9),
1604. 1604 "watch it every day",
1605. 1605 "s1",
1606. 1606 dir.path(),
1607. 1607 )
1608. 1608 .unwrap();
1609. 1609
1610. 1610 // Not yet expired.
1611. 1611 assert!(sweep_expired(dir.path()).is_empty());
1612. 1612
1613. 1613 // An over-budget commitment is held by the scheduler, never closed.
1614. 1614 ledger
1615. 1615 .append(&Event::new(
1616. 1616 &handle.commitment_id,
1617. 1617 EventKind::EpisodeEnded {
1618. 1618 episode_id: handle.episode_id.clone(),
1619. 1619 advancement: Advancement::Learned { fact: "x".into() },
1620. 1620 spend_usd: 9_999.0,
1621. 1621 },
1622. 1622 ))
1623. 1623 .unwrap();
1624. 1624 assert!(sweep_expired(dir.path()).is_empty());
1625. 1625 let commitment = ledger.get(&handle.commitment_id).unwrap().unwrap();
1626. 1626 assert!(
1627. 1627 commitment.is_over_budget() || commitment.spec.economics.lifetime_budget_usd.is_none()
1628. 1628 );
1629. 1629 assert!(!commitment.phase.is_terminal());
1630. 1630 }
1631. 1631}
1632. 1632