1411. 1411 let reading = Reading {
1412. 1412 evidence: Evidence::Cited,
1413. 1413 ..Reading::general()
1414. 1414 };
1415. 1415 let spec = OutcomeSpec::from_reading("research", &reading, 1);
1416. 1416 let partial = vec![
1417. 1417 RequirementEvaluation {
1418. 1418 requirement_id: "deliverable-1".into(),
1419. 1419 status: RequirementStatus::Met,
1420. 1420 reason: "content exists".into(),
1421. 1421 },
1422. 1422 RequirementEvaluation {
1423. 1423 requirement_id: "evidence-1".into(),
1424. 1424 status: RequirementStatus::Unmet,
1425. 1425 reason: "no linked evidence".into(),
1426. 1426 },
1427. 1427 ];
1428. 1428 assert_eq!(
1429. 1429 evaluate_completion(OutcomeStatus::Produced, &partial, &spec),
1430. 1430 CompletionVerdict::Partial
1431. 1431 );
1432. 1432 assert_eq!(
1433. 1433 evaluate_completion(OutcomeStatus::Failed, &[], &spec),
1434. 1434 CompletionVerdict::Failed
1435. 1435 );
1436. 1436 assert_eq!(
1437. 1437 evaluate_completion(OutcomeStatus::Cancelled, &[], &spec),
1438. 1438 CompletionVerdict::Cancelled
1439. 1439 );
1440. 1440 }
1441. 1441
1442. 1442 #[test]
1443. 1443 fn review_state_is_deterministic() {
1444. 1444 assert_eq!(
1445. 1445 human_review_state(CompletionVerdict::Complete),
1446. 1446 "not_required"
1447. 1447 );
1448. 1448 assert_eq!(
1449. 1449 human_review_state(CompletionVerdict::Unknown),
1450. 1450 "recommended"
1451. 1451 );
1452. 1452 assert_eq!(
1453. 1453 human_review_state(CompletionVerdict::Failed),
1454. 1454 "required_for_recovery"
1455. 1455 );
1456. 1456 }
1457. 1457
1458. 1458 #[test]
1459. 1459 fn only_explicit_commands_are_control() {
1460. 1460 assert_eq!(parse_command("/status"), Some(Command::Status));
1461. 1461 assert_eq!(parse_command("/stop"), Some(Command::Cancel));
1462. 1462 assert_eq!(parse_command("Stop!"), Some(Command::Cancel));
1463. 1463 assert_eq!(parse_command("pause"), Some(Command::Pause));
1464. 1464 assert_eq!(
1465. 1465 parse_command("/replan around the new constraint"),
1466. 1466 Some(Command::Replan {
1467. 1467 text: "around the new constraint".into()
1468. 1468 })
1469. 1469 );
1470. 1470 assert_eq!(
1471. 1471 parse_command("/goal replace ship the index only"),
1472. 1472 Some(Command::GoalReplace {
1473. 1473 text: "ship the index only".into()
1474. 1474 })
1475. 1475 );
1476. 1476 assert_eq!(
1477. 1477 parse_command("/approve gate-7"),
1478. 1478 Some(Command::Approve {
1479. 1479 gate_id: "gate-7".into()
1480. 1480 })
1481. 1481 );
1482. 1482 // Natural language is steering, whatever word it starts with.
1483. 1483 for text in [
1484. 1484 "stop using semicolons in the output",
1485. 1485 "pause the music service before deploying",
1486. 1486 "also include a CSV",
1487. 1487 "status of the migration please",
1488. 1488 "replace the deprecated API call",
1489. 1489 "use a shorter answer",
1490. 1490 ] {
1491. 1491 assert_eq!(parse_command(text), None, "{text}");
1492. 1492 }
1493. 1493 // A slash command without its argument is not a command either.
1494. 1494 assert_eq!(parse_command("/replan"), None);
1495. 1495 assert_eq!(parse_command("/goal replace"), None);
1496. 1496 }
1497. 1497
1498. 1498 fn intervention(kind: InterventionKind, source: ControlSource) -> InterventionRequest {
1499. 1499 InterventionRequest {
1500. 1500 request_id: "i-1".into(),
1501. 1501 kind,
1502. 1502 text: String::new(),
1503. 1503 source,
1504. 1504 target_revision: Some(1),
1505. 1505 target_session_id: Some("child".into()),
1506. 1506 target_parent_session_id: Some("parent".into()),
1507. 1507 }
1508. 1508 }
1509. 1509
1510. 1510 fn human() -> ControlSource {
1511. 1511 ControlSource::Human {
1512. 1512 surface: "desktop".into(),
1513. 1513 principal: None,
1514. 1514 }
1515. 1515 }
1516. 1516
1517. 1517 fn agent(session_id: &str) -> ControlSource {
1518. 1518 ControlSource::Agent {
1519. 1519 session_id: session_id.into(),
1520. 1520 parent_session_id: None,
1521. 1521 }
1522. 1522 }
1523. 1523
1524. 1524 fn system() -> ControlSource {
1525. 1525 ControlSource::System {
1526. 1526 origin: "webhook".into(),
1527. 1527 }
1528. 1528 }
1529. 1529
1530. 1530 /// The authority matrix: humans may do anything, agents only their own
1531. 1531 /// children, systems only observe.
1532. 1532 #[test]
1533. 1533 fn intervention_authority_comes_from_the_source() {
1534. 1534 use InterventionDecision as D;
1535. 1535 use InterventionKind as K;
1536. 1536 let decide = |kind: K, source: ControlSource| {
1537. 1537 evaluate_intervention(intervention(kind, source)).decision
1538. 1538 };
1539. 1539
1540. 1540 assert_eq!(decide(K::Cancel, human()), D::Accepted);
1541. 1541 assert_eq!(decide(K::Replan, human()), D::Queued);
1542. 1542 assert_eq!(decide(K::Approve, human()), D::Accepted);
1543. 1543 assert!(evaluate_intervention(intervention(K::Replan, human())).creates_revision);
1544. 1544
1545. 1545 // An agent controlling a child it dispatched.
1546. 1546 assert_eq!(decide(K::Cancel, agent("parent")), D::Accepted);
1547. 1547 // An agent trying to control the session it lives in — or one that
1548. 1548 // is not its child — is refused.
1549. 1549 assert_eq!(decide(K::Cancel, agent("child")), D::Rejected);
1550. 1550 assert_eq!(decide(K::Cancel, agent("sibling")), D::Rejected);
1551. 1551 assert_eq!(decide(K::Pause, agent("stranger")), D::Rejected);
1552. 1552 assert_eq!(decide(K::Resume, agent("stranger")), D::Rejected);
1553. 1553 // Without the target's parentage there is nothing to prove, so the
1554. 1554 // answer is no.
1555. 1555 let mut unknown_parent = intervention(K::Cancel, agent("parent"));
1556. 1556 unknown_parent.target_parent_session_id = None;
1557. 1557 assert_eq!(evaluate_intervention(unknown_parent).decision, D::Rejected);
1558. 1558 assert_eq!(decide(K::Replan, agent("parent")), D::RequiresHuman);
1559. 1559 assert_eq!(decide(K::Approve, agent("parent")), D::Rejected);
1560. 1560
1561. 1561 assert_eq!(decide(K::Status, system()), D::Accepted);
1562. 1562 assert_eq!(decide(K::Resume, system()), D::Accepted);
1563. 1563 assert_eq!(decide(K::Cancel, system()), D::Rejected);
1564. 1564 assert_eq!(decide(K::Steer, system()), D::Rejected);
1565. 1565 assert_eq!(decide(K::Approve, system()), D::Rejected);
1566. 1566 }
1567. 1567
1568. 1568 #[test]
1569. 1569 fn domain_verification_oracles_validate_tables_matrices_citations() {
1570. 1570 // Tabular markdown: well-formed
1571. 1571 let valid_table = "| Col A | Col B |\n| --- | --- |\n| Val 1 | Val 2 |\n| Val 3 | Val 4 |";
1572. 1572 assert!(verify_tabular_data(valid_table).unwrap().is_ok());
1573. 1573
1574. 1574 // Tabular markdown: ragged (col count mismatch)
1575. 1575 let ragged_table = "| Col A | Col B |\n| --- | --- |\n| Val 1 |\n| Val 3 | Val 4 |";
1576. 1576 assert!(verify_tabular_data(ragged_table).unwrap().is_err());
1577. 1577
1578. 1578 // Tabular vak block
1579. 1579 let valid_block = "```vak-table\n{\"columns\": [\"A\", \"B\"], \"rows\": [[\"1\", \"2\"], [\"3\", \"4\"]]}\n```";
1580. 1580 assert!(verify_tabular_data(valid_block).unwrap().is_ok());
1581. 1581
1582. 1582 let invalid_block =
1583. 1583 "```vak-table\n{\"columns\": [\"A\", \"B\"], \"rows\": [[\"1\"], [\"3\", \"4\"]]}\n```";
1584. 1584 assert!(verify_tabular_data(invalid_block).unwrap().is_err());
1585. 1585
1586. 1586 // Decision matrix vak block
1587. 1587 let valid_matrix = "```vak-decision\n{\"options\": [{\"label\": \"Option A\"}, {\"label\": \"Option B\"}]}\n```";
1588. 1588 assert!(verify_decision_matrix(valid_matrix).unwrap().is_ok());
1589. 1589
1590. 1590 let single_option_matrix =
1591. 1591 "```vak-decision\n{\"options\": [{\"label\": \"Option A\"}]}\n```";
1592. 1592 assert!(
1593. 1593 verify_decision_matrix(single_option_matrix)
1594. 1594 .unwrap()
1595. 1595 .is_err()
1596. 1596 );
1597. 1597
1598. 1598 // Claim citations
1599. 1599 let valid_citations =
1600. 1600 "According to study[^1] and report[^2].\n\n[^1]: Reference one\n[^2]: Reference two";
1601. 1601 assert!(verify_claim_citations(valid_citations).unwrap().is_ok());
1602. 1602
1603. 1603 let unlinked_citations = "According to study[^1] and missing[^3].\n\n[^1]: Reference one";
1604. 1604 assert!(verify_claim_citations(unlinked_citations).unwrap().is_err());
1605. 1605
1606. 1606 // RequirementKind::Integrity evaluation
1607. 1607 let mut spec = OutcomeSpec::from_reading("produce analysis", &Reading::general(), 1);
1608. 1608 spec.merge_declared_requirement(
1609. 1609 "integ-1",
1610. 1610 "integrity",
1611. 1611 "verify data integrity",
1612. 1612 "must",
1613. 1613 None,
1614. 1614 )
1615. 1615 .unwrap();
1616. 1616
1617. 1617 let good_eval =
1618. 1618 evaluate_requirements_with_state(&spec, Some(valid_table), EvidenceState::None);
1619. 1619 let integ_eval = good_eval
1620. 1620 .iter()
1621. 1621 .find(|e| e.requirement_id == "integ-1")
1622. 1622 .unwrap();
1623. 1623 assert_eq!(integ_eval.status, RequirementStatus::Met);
1624. 1624
1625. 1625 let bad_eval =
1626. 1626 evaluate_requirements_with_state(&spec, Some(ragged_table), EvidenceState::None);
1627. 1627 let bad_integ = bad_eval
1628. 1628 .iter()
1629. 1629 .find(|e| e.requirement_id == "integ-1")
1630. 1630 .unwrap();
1631. 1631 assert_eq!(bad_integ.status, RequirementStatus::Unmet);
1632. 1632 }
1633. 1633}
1634. 1634