1193. 1193 let file = OutcomeSpec::from_reading(
1194. 1194 "Create an invitation in this workspace as invitation.html",
1195. 1195 &authoring,
1196. 1196 1,
1197. 1197 );
1198. 1198 assert!(file.expects_saved_file());
1199. 1199 let plan = OutcomeSpec::from_reading("Create a two-day lunch plan", &authoring, 1);
1200. 1200 assert!(!plan.expects_saved_file());
1201. 1201 let inspection = OutcomeSpec::from_reading("Explain README.md", &Reading::general(), 1);
1202. 1202 assert!(!inspection.expects_saved_file());
1203. 1203 // Naming a file inside a question is not asking for one.
1204. 1204 let explanation =
1205. 1205 OutcomeSpec::from_reading("explain how to write a README.md", &Reading::general(), 1);
1206. 1206 assert!(!explanation.expects_saved_file());
1207. 1207 assert!(!explanation.requires_execution());
1208. 1208 }
1209. 1209
1210. 1210 #[test]
1211. 1211 fn baseline_contract_preserves_objective_and_adds_only_inferred_requirements() {
1212. 1212 let reading = Reading {
1213. 1213 act: Act::Answer,
1214. 1214 evidence: Evidence::Cited,
1215. 1215 ..Reading::general()
1216. 1216 };
1217. 1217 let spec = OutcomeSpec::from_reading("current events in India", &reading, 1);
1218. 1218 assert_eq!(spec.objective, "current events in India");
1219. 1219 assert!(spec.requirements.iter().any(|requirement| {
1220. 1220 requirement.kind == RequirementKind::Evidence
1221. 1221 && requirement.origin == RequirementOrigin::Inferred
1222. 1222 && requirement.importance == RequirementImportance::Must
1223. 1223 }));
1224. 1224 assert!(
1225. 1225 spec.requirements
1226. 1226 .iter()
1227. 1227 .all(|requirement| { requirement.origin == RequirementOrigin::Inferred })
1228. 1228 );
1229. 1229 }
1230. 1230
1231. 1231 #[test]
1232. 1232 fn produced_output_is_not_called_complete() {
1233. 1233 assert_eq!(
1234. 1234 evaluate_response(Some("answer"), false, false),
1235. 1235 OutcomeStatus::Produced
1236. 1236 );
1237. 1237 }
1238. 1238
1239. 1239 #[test]
1240. 1240 fn refusal_cannot_satisfy_a_deliverable_requirement() {
1241. 1241 let mut spec = OutcomeSpec::from_reading("create a report", &Reading::general(), 1);
1242. 1242 assert!(
1243. 1243 spec.merge_declared_requirement(
1244. 1244 "report",
1245. 1245 "deliverable",
1246. 1246 "create report.md",
1247. 1247 "must",
1248. 1248 None
1249. 1249 )
1250. 1250 .is_ok()
1251. 1251 );
1252. 1252 let evaluations = evaluate_requirements(&spec, Some("I cannot do that."));
1253. 1253 assert_eq!(evaluations[1].status, RequirementStatus::Unknown);
1254. 1254 assert_eq!(
1255. 1255 evaluate_completion(OutcomeStatus::Produced, &evaluations, &spec),
1256. 1256 CompletionVerdict::Unknown
1257. 1257 );
1258. 1258 }
1259. 1259
1260. 1260 #[test]
1261. 1261 fn cited_output_remains_unknown_until_source_support_is_checked() {
1262. 1262 let reading = Reading {
1263. 1263 evidence: Evidence::Cited,
1264. 1264 ..Reading::general()
1265. 1265 };
1266. 1266 let spec = OutcomeSpec::from_reading("research", &reading, 1);
1267. 1267 let evaluations = evaluate_requirements(&spec, Some("claim https://example.com"));
1268. 1268 assert_eq!(evaluations[0].status, RequirementStatus::Met);
1269. 1269 assert_eq!(evaluations[1].status, RequirementStatus::Unknown);
1270. 1270 }
1271. 1271
1272. 1272 #[test]
1273. 1273 fn retrieval_receipt_is_not_mistaken_for_supported_evidence() {
1274. 1274 let reading = Reading {
1275. 1275 evidence: Evidence::Cited,
1276. 1276 ..Reading::general()
1277. 1277 };
1278. 1278 let spec = OutcomeSpec::from_reading("research", &reading, 1);
1279. 1279 let evaluations =
1280. 1280 evaluate_requirements_with_evidence(&spec, Some("claim https://example.com"), true);
1281. 1281 assert_eq!(evaluations[1].status, RequirementStatus::Unknown);
1282. 1282 assert!(evaluations[1].reason.contains("receipt"));
1283. 1283 }
1284. 1284
1285. 1285 #[test]
1286. 1286 fn missing_and_unlinked_evidence_are_distinct_failures() {
1287. 1287 let reading = Reading {
1288. 1288 evidence: Evidence::Cited,
1289. 1289 ..Reading::general()
1290. 1290 };
1291. 1291 let spec = OutcomeSpec::from_reading("research", &reading, 1);
1292. 1292 let missing = evaluate_requirements(&spec, Some("plain answer"));
1293. 1293 assert_eq!(missing[1].status, RequirementStatus::Unmet);
1294. 1294 let unlinked = evaluate_requirements(&spec, Some("answer https://example.com"));
1295. 1295 assert_eq!(unlinked[1].status, RequirementStatus::Unknown);
1296. 1296 assert!(unlinked[1].reason.contains("support and freshness"));
1297. 1297 }
1298. 1298
1299. 1299 #[test]
1300. 1300 fn stale_evidence_is_unknown_and_explains_why() {
1301. 1301 let reading = Reading {
1302. 1302 evidence: Evidence::Cited,
1303. 1303 ..Reading::general()
1304. 1304 };
1305. 1305 let spec = OutcomeSpec::from_reading("current events", &reading, 1);
1306. 1306 let evaluations = evaluate_requirements_with_state(
1307. 1307 &spec,
1308. 1308 Some("answer https://example.com"),
1309. 1309 EvidenceState::Stale,
1310. 1310 );
1311. 1311 assert_eq!(evaluations[1].status, RequirementStatus::Unknown);
1312. 1312 assert!(evaluations[1].reason.contains("stale"));
1313. 1313 }
1314. 1314
1315. 1315 #[test]
1316. 1316 #[allow(clippy::expect_used)]
1317. 1317 fn evidence_receipt_keeps_observation_and_source_times_distinct() {
1318. 1318 let observed = chrono::DateTime::parse_from_rfc3339("2026-01-02T00:00:00Z")
1319. 1319 .expect("timestamp")
1320. 1320 .with_timezone(&chrono::Utc);
1321. 1321 let published = chrono::DateTime::parse_from_rfc3339("2025-12-31T00:00:00Z")
1322. 1322 .expect("timestamp")
1323. 1323 .with_timezone(&chrono::Utc);
1324. 1324 let receipt = EvidenceReceipt {
1325. 1325 id: "r1".into(),
1326. 1326 kind: "article".into(),
1327. 1327 producer: "web".into(),
1328. 1328 observed_at: observed,
1329. 1329 source_published_at: Some(published),
1330. 1330 effective_at: None,
1331. 1331 state: EvidenceState::Fresh,
1332. 1332 };
1333. 1333 assert_eq!(receipt.freshness_timestamp(), published);
1334. 1334 assert_eq!(receipt.observed_at, observed);
1335. 1335 assert_eq!(
1336. 1336 evidence_state_from_receipt(observed, &receipt, chrono::Duration::days(1)),
1337. 1337 EvidenceState::Stale
1338. 1338 );
1339. 1339 }
1340. 1340
1341. 1341 #[test]
1342. 1342 fn evidence_freshness_is_deterministic_and_domain_configurable() {
1343. 1343 let now = chrono::Utc::now();
1344. 1344 assert_eq!(
1345. 1345 evidence_state_from_age(
1346. 1346 now,
1347. 1347 now - chrono::Duration::hours(1),
1348. 1348 chrono::Duration::hours(2)
1349. 1349 ),
1350. 1350 EvidenceState::Fresh
1351. 1351 );
1352. 1352 assert_eq!(
1353. 1353 evidence_state_from_age(
1354. 1354 now,
1355. 1355 now - chrono::Duration::hours(3),
1356. 1356 chrono::Duration::hours(2)
1357. 1357 ),
1358. 1358 EvidenceState::Stale
1359. 1359 );
1360. 1360 assert_eq!(
1361. 1361 evidence_state_from_age(
1362. 1362 now,
1363. 1363 now + chrono::Duration::minutes(1),
1364. 1364 chrono::Duration::hours(2)
1365. 1365 ),
1366. 1366 EvidenceState::Fresh
1367. 1367 );
1368. 1368 }
1369. 1369
1370. 1370 #[test]
1371. 1371 fn extension_requirements_are_data_driven_and_narrowing_only() {
1372. 1372 let mut spec = OutcomeSpec::from_reading("make a plan", &Reading::general(), 1);
1373. 1373 let result = spec.merge_declared_requirement(
1374. 1374 "plan-structure",
1375. 1375 "constraint",
1376. 1376 "include assumptions and next steps",
1377. 1377 "must",
1378. 1378 Some("primary".into()),
1379. 1379 );
1380. 1380 assert!(result.is_ok());
1381. 1381 assert_eq!(
1382. 1382 spec.requirements.last().map(|item| item.origin),
1383. 1383 Some(RequirementOrigin::Inferred)
1384. 1384 );
1385. 1385 assert!(
1386. 1386 spec.merge_declared_requirement("", "constraint", "x", "must", None)
1387. 1387 .is_err()
1388. 1388 );
1389. 1389 assert!(
1390. 1390 spec.merge_declared_requirement("bad", "grant", "x", "must", None)
1391. 1391 .is_err()
1392. 1392 );
1393. 1393 }
1394. 1394
1395. 1395 #[test]
1396. 1396 fn completion_verdict_never_confuses_output_with_satisfaction() {
1397. 1397 let reading = Reading {
1398. 1398 evidence: Evidence::Cited,
1399. 1399 ..Reading::general()
1400. 1400 };
1401. 1401 let spec = OutcomeSpec::from_reading("research", &reading, 1);
1402. 1402 let evaluations = evaluate_requirements(&spec, Some("answer https://example.com"));
1403. 1403 assert_eq!(
1404. 1404 evaluate_completion(OutcomeStatus::Produced, &evaluations, &spec),
1405. 1405 CompletionVerdict::Unknown
1406. 1406 );
1407. 1407 }
1408. 1408
1409. 1409 #[test]
1410. 1410 fn completion_verdict_handles_partial_failed_and_cancelled_work() {
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