Vakyartha documentation

1599 ..Classification::default()
1600 }],
1601 "m",
1602 "d",
1603 &Authority::default(),
1604 &ResolverConfig::default(),
1605 false,
1606 );
1607 assert_eq!(after.provenance.tier, Tier::LocalModel);
1608 assert!(after.reading.domains.contains("web"));
1609 assert!(!after.reading.domains.contains("weather"));
1610 }
1611
1612 #[test]
1613 fn operate_is_never_assumed_cheap_and_governing_is_reversible() {
1614 assert_eq!(implied_stakes(Act::Operate), Stakes::Irreversible);
1615 assert_eq!(implied_stakes(Act::Govern), Stakes::Reversible);
1616 assert_eq!(implied_stakes(Act::Answer), Stakes::Inert);
1617 }
1618
1619 /// Below the acceptance bar the turn gets the orientation floor, never a
1620 /// guessed slice and never everything.
1621 #[test]
1622 fn provisional_readings_get_the_orientation_floor() {
1623 let config = ResolverConfig {
1624 accept_confidence: 0.99,
1625 provisional_confidence: 0.0,
1626 ..ResolverConfig::default()
1627 };
1628 let resolution = resolve(
1629 &request("explain the deploy script"),
1630 &Declared::default(),
1631 &Authority::default(),
1632 &config,
1633 );
1634 assert_eq!(
1635 resolution.peek().engagement.limits.required_domains,
1636 Engagement::orienting().limits.required_domains
1637 );
1638 }
1639
1640 #[test]
1641 fn a_confident_reading_does_slice() {
1642 let resolution = resolve_text("hello");
1643 assert!(
1644 !resolution
1645 .peek()
1646 .engagement
1647 .limits
1648 .required_domains
1649 .is_empty()
1650 );
1651 }
1652
1653 // ----------------------------------------------------------- strands ---
1654
1655 #[test]
1656 fn a_compound_request_becomes_ordered_strands_with_the_union_of_domains() {
1657 let intent = resolve_text("first explain the parser, then refactor it").intent();
1658 assert_eq!(intent.strands.len(), 2);
1659 assert_eq!(intent.strands[0].reading.act, Act::Answer);
1660 assert_eq!(intent.strands[1].reading.act, Act::Modify);
1661 assert_eq!(
1662 intent.strands[1].relation,
1663 StrandRelation::Sequential {
1664 after: intent.strands[0].strand_id.clone()
1665 }
1666 );
1667 // Composite: the consequential strand, widened by the other.
1668 assert_eq!(intent.reading.act, Act::Modify);
1669 assert!(intent.reading.alternate_acts.contains(&Act::Answer));
1670 // The slice covers both parts.
1671 let domains = &intent.engagement.limits.required_domains;
1672 assert!(domains.contains("live-data"), "answer's domains lost");
1673 assert!(domains.contains("code-exec"), "modify's domains lost");
1674 // And the model is told there are two parts, without the request
1675 // being quoted back at it.
1676 let note = intent.engagement.posture.note.as_deref().unwrap();
1677 assert!(note.contains("2 parts"), "{note}");
1678 assert!(note.contains("after part 1"), "{note}");
1679 for strand in &intent.strands {
1680 assert!(!note.contains(strand.text.trim()), "quoted: {note}");
1681 }
1682 }
1683
1684 /// Strand ids come from the host's turn id, so a thread — and the
1685 /// commitment keyed by it — never collides with another turn's.
1686 #[test]
1687 fn strand_ids_come_from_the_turn_id() {
1688 let mut req = request("fix the login bug. Also check whether the nightly job ran");
1689 req.turn_id = "0199a1b2-7c3d-7e4f-8a9b-0c1d2e3f4a5b";
1690 let intent = resolve(
1691 &req,
1692 &Declared::default(),
1693 &Authority::default(),
1694 &ResolverConfig::default(),
1695 )
1696 .intent();
1697 assert_eq!(
1698 intent.strands[0].strand_id,
1699 "0199a1b2-7c3d-7e4f-8a9b-0c1d2e3f4a5b.0"
1700 );
1701 assert_eq!(
1702 intent.strands[1].thread_id,
1703 "0199a1b2-7c3d-7e4f-8a9b-0c1d2e3f4a5b.1"
1704 );
1705 }
1706
1707 #[test]
1708 fn conversational_card_delivery_is_an_answer_not_workspace_authoring() {
1709 for text in [
1710 "Give me the latest India news and present it as a card",
1711 "What is the current weather in Delhi? Show it as a card",
1712 ] {
1713 let intent = resolve_text(text).intent();
1714 assert_eq!(intent.reading.act, Act::Answer, "{text}");
1715 assert!(
1716 intent
1717 .strands
1718 .iter()
1719 .all(|strand| strand.reading.act != Act::Author),
1720 "{text}: {:?}",
1721 intent.strands
1722 );
1723 assert!(intent.reading.domains.contains("live-data"), "{text}");
1724 }
1725 }
1726
1727 #[test]
1728 fn unrelated_strands_are_independent_threads() {
1729 let intent =
1730 resolve_text("fix the login bug. Also check whether the nightly job ran").intent();
1731 assert_eq!(intent.strands.len(), 2);
1732 assert_eq!(intent.strands[1].relation, StrandRelation::Independent);
1733 assert_ne!(intent.strands[0].thread_id, intent.strands[1].thread_id);
1734 assert!(matches!(intent.strands[0].lineage, Lineage::New));
1735 }
1736
1737 #[test]
1738 fn a_strand_continues_an_open_thread_it_points_at() {
1739 let mut req = request("now refactor it");
1740 req.history.turn_index = 2;
1741 req.history.open_threads = vec![ThreadFact {
1742 thread_id: "s0.0".into(),
1743 act: Act::Modify,
1744 domains: BTreeSet::new(),
1745 keywords: crate::strand::keywords("fix the parser"),
1746 }];
1747 let intent = resolve(
1748 &req,
1749 &Declared::default(),
1750 &Authority::default(),
1751 &ResolverConfig::default(),
1752 )
1753 .intent();
1754 assert_eq!(
1755 intent.strands[0].lineage,
1756 Lineage::Continues {
1757 thread_id: "s0.0".into()
1758 }
1759 );
1760 assert_eq!(intent.strands[0].thread_id, "s0.0");
1761 }
1762
1763 /// Corrections and replacements are never inferred from text, and a
1764 /// replacement starts a thread of its own.
1765 #[test]
1766 fn corrections_only_come_from_an_explicit_hint() {
1767 let thread = ThreadFact {
1768 thread_id: "s0.0".into(),
1769 act: Act::Modify,
1770 domains: BTreeSet::new(),
1771 keywords: crate::strand::keywords("refactor the parser"),
1772 };
1773 let mut req = request("actually refactor the parser to use a state machine instead");
1774 req.history.turn_index = 1;
1775 req.history.open_threads = vec![thread.clone()];
1776 let inferred = resolve(
1777 &req,
1778 &Declared::default(),
1779 &Authority::default(),
1780 &ResolverConfig::default(),
1781 )
1782 .intent();
1783 assert!(matches!(
1784 inferred.strands[0].lineage,
1785 Lineage::Continues { .. }
1786 ));
1787
1788 req.lineage_hint = Some(LineageHint::Replaces);
1789 let explicit = resolve(
1790 &req,
1791 &Declared::default(),
1792 &Authority::default(),
1793 &ResolverConfig::default(),
1794 )
1795 .intent();
1796 assert_eq!(
1797 explicit.strands[0].lineage,
1798 Lineage::Replaces {
1799 thread_id: "s0.0".into()
1800 }
1801 );
1802 assert_eq!(explicit.strands[0].thread_id, explicit.strands[0].strand_id);
1803 }
1804
1805 /// A greeting beside real work is context for it, not a part of its own.
1806 #[test]
1807 fn a_greeting_beside_real_work_is_not_a_part() {
1808 let intent = resolve_text("hi! then refactor the parser").intent();
1809 assert_eq!(intent.strands.len(), 1, "{:?}", intent.strands);
1810 assert_eq!(intent.reading.act, Act::Modify);
1811 assert!(intent.engagement.posture.note.is_none());
1812 }
1813
1814 #[test]
1815 fn the_strictest_strand_governs_authority() {
1816 let intent =
1817 resolve_text("summarise the changelog, then deploy the service to production").intent();
1818 assert_eq!(
1819 intent.engagement.limits.approval_ceiling,
1820 crate::ApprovalCeiling::Ask
1821 );
1822 assert_eq!(intent.reading.stakes, Stakes::Irreversible);
1823 assert_eq!(intent.engagement.posture.stop, crate::StopProfile::Effect);
1824 }
1825
1826 #[test]
1827 fn per_strand_classifications_apply_in_order() {
1828 let partial = resolve_text("first explain the parser, then refactor it").intent();
1829 let answer = apply_classification(
1830 partial,
1831 &[
1832 Classification {
1833 evidence: Some("cited".into()),
1834 confidence: Some(0.9),
1835 ..Classification::default()
1836 },
1837 Classification {
1838 horizon: Some("session".into()),
1839 confidence: Some(0.9),
1840 ..Classification::default()
1841 },
1842 ],
1843 "m",
1844 "d",
1845 &Authority::default(),
1846 &ResolverConfig::default(),
1847 false,
1848 );
1849 assert_eq!(answer.strands[0].reading.evidence, Evidence::Cited);
1850 assert_eq!(answer.strands[1].reading.horizon, Horizon::Session);
1851 assert_ne!(answer.strands[0].reading.horizon, Horizon::Session);
1852 }
1853
1854 /// A classifier that splits the request differently than the segmenter
1855 /// is still evidence: its objects fold on the cautious side and apply
1856 /// to every strand, never discarded.
1857 #[test]
1858 fn a_mismatched_classification_count_folds_cautiously() {
1859 let partial = resolve_text("zorble the frobnicator, then flimflam the widget").intent();
1860 assert_eq!(partial.strands.len(), 1);
1861 let answer = apply_classification(
1862 partial,
1863 &[
1864 Classification {
1865 act: Some("answer".into()),
1866 stakes: Some("inert".into()),
1867 confidence: Some(0.9),
1868 ..Classification::default()
1869 },
1870 Classification {
1871 act: Some("modify".into()),
1872 stakes: Some("costly".into()),
1873 evidence: Some("verified".into()),
1874 confidence: Some(0.6),
1875 ..Classification::default()
1876 },
1877 ],
1878 "m",
1879 "d",
1880 &Authority::default(),
1881 &ResolverConfig::default(),
1882 false,
1883 );
1884 assert_eq!(answer.provenance.tier, Tier::LocalModel);
1885 assert_eq!(answer.reading.act, Act::Modify);
1886 assert_eq!(answer.reading.stakes, Stakes::Costly);
1887 assert_eq!(answer.reading.evidence, Evidence::Verified);
1888 assert!((answer.reading.axis_confidence.act - 0.6).abs() < 1e-9);
1889 }
1890
1891 #[test]
1892 fn classifier_answers_parse_leniently() {
1893 let parsed = parse_classifications("```json\n[{\"act\":\"modify\"}]\n```").unwrap();
1894 assert_eq!(parsed.len(), 1);
1895 assert_eq!(parsed[0].act.as_deref(), Some("modify"));
1896 let parsed =
1897 parse_classifications("Sure: {\"act\":\"Answer\",\"confidence\":0.5} hope that helps")
1898 .unwrap();
1899 assert_eq!(parsed[0].act.as_deref(), Some("answer"));
1900 assert_eq!(parsed[0].confidence, Some(0.5));
1901 let parsed =
1902 parse_classifications("[{\"domains\":\"web, live-data\",\"confidence\":\"0.8\"}]")
1903 .unwrap();
1904 assert_eq!(parsed[0].domains, vec!["web", "live-data"]);
1905 assert_eq!(parsed[0].confidence, Some(0.8));
1906 assert!(parse_classifications("no json here").is_err());
1907 }
1908
1909 #[test]
1910 fn the_classifier_prompt_bounds_each_part() {
1911 let long = format!("explain {}", "the parser in great detail ".repeat(40));
1912 let intent = resolve_text(&long).intent();
1913 let prompt = classification_prompt(&intent);
1914 let part = prompt.lines().find(|line| line.starts_with("1. ")).unwrap();
1915 assert!(part.chars().count() <= PROMPT_PART_CHARS + 4, "{part}");
1916 assert!(classification_budget(1) >= 200);
1917 assert!(classification_budget(50) <= 1_600);
1918 }
1919
1920 /// Regression corpus for the lexical false positives two reviews found.
1921 #[test]
1922 fn everyday_requests_do_not_grow_horizons_stakes_or_evidence() {
1923 let cases: &[(&str, Horizon, Stakes, Evidence)] = &[
1924 (
1925 "fix the authentication bug in the login handler",
1926 Horizon::Turn,
1927 Stakes::Reversible,
1928 Evidence::None,
1929 ),
1930 (
1931 "wait until the build finishes and tell me",
1932 Horizon::Turn,
1933 Stakes::Inert,
1934 Evidence::None,
1935 ),
1936 (
1937 "where does this config live",
1938 Horizon::Turn,
1939 Stakes::Inert,
1940 Evidence::None,
1941 ),
1942 (
1943 "explain the customer model in this codebase",
1944 Horizon::Turn,
1945 Stakes::Inert,
1946 Evidence::None,
1947 ),
1948 (
1949 "how does our production deploy work?",
1950 Horizon::Turn,
1951 Stakes::Inert,
1952 Evidence::None,
1953 ),
1954 (
1955 "look at the source code for the parser",
1956 Horizon::Turn,
1957 Stakes::Inert,
1958 Evidence::None,
1959 ),
1960 (
1961 "rename the Customer struct to Client",
1962 Horizon::Turn,
1963 Stakes::Reversible,
1964 Evidence::None,
1965 ),
1966 (
1967 "fix the payment form validation",
1968 Horizon::Turn,
1969 Stakes::Reversible,
1970 Evidence::None,
1971 ),
1972 (
1973 "remember that I prefer tabs over spaces",
1974 Horizon::Turn,
1975 Stakes::Reversible,
1976 Evidence::None,
1977 ),
1978 (
1979 "what happens whenever I press ctrl-c in the REPL?",
1980 Horizon::Turn,
1981 Stakes::Inert,
1982 Evidence::None,
1983 ),
1984 (
1985 "explain step by step how the borrow checker works",
1986 Horizon::Turn,
1987 Stakes::Inert,
1988 Evidence::None,
1989 ),
1990 (
1991 "write a poem about the sea and make sure it rhymes",
1992 Horizon::Turn,
1993 Stakes::Reversible,
1994 Evidence::None,
1995 ),
1996 ];
1997 for (text, horizon, stakes, evidence) in cases {
1998 let intent = resolve_text(text).intent();
1999 assert_eq!(intent.reading.horizon, *horizon, "{text}");
2000 assert_eq!(intent.reading.stakes, *stakes, "{text}");
2001 assert_eq!(intent.reading.evidence, *evidence, "{text}");
2002 assert!(!intent.engagement.posture.open_commitment, "{text}");
2003 assert_ne!(
2004 intent.engagement.limits.approval_ceiling,
2005 crate::ApprovalCeiling::Ask,
2006 "{text}"
2007 );
2008 }
2009 // A recurrence adjective names a thing, not a schedule.
2010 let adjective = resolve_text("check whether the nightly job ran").intent();
2011 assert_ne!(adjective.reading.horizon, Horizon::Durable);
2012 assert!(!adjective.engagement.posture.open_commitment);
2013 let adverb = resolve_text("check the cloud bill nightly and alert me").intent();
2014 assert_eq!(adverb.reading.horizon, Horizon::Durable);
2015 // And the ones that should still fire, still do.
2016 let deploy = resolve_text("deploy the service to production").intent();
2017 assert_eq!(deploy.reading.stakes, Stakes::Irreversible);
2018 let nightly = resolve_text("check the cloud bill every day and alert me").intent();
2019 assert_eq!(nightly.reading.horizon, Horizon::Durable);
2020 assert!(nightly.engagement.posture.open_commitment);
2021 let cited = resolve_text("summarise the paper and cite your sources").intent();
2022 assert_eq!(cited.reading.evidence, Evidence::Cited);
2023 }
2024
2025 /// Temporal words ask for a live value only beside a request for a fact.
2026 #[test]
2027 fn live_data_follows_a_request_for_a_fact() {
2028 for text in [
2029 "what is the current price of copper",
2030 "what's the weather in Delhi today",
2031 "give me the latest headlines",
2032 ] {
2033 let intent = resolve_text(text).intent();
2034 assert!(intent.reading.domains.contains("live-data"), "{text}");
2035 }
2036 for text in [
2037 "Refactor the current implementation of the parser to use a state machine",
2038 "update the README to reflect the latest changes",
2039 "fix the live reload bug in the dev server",
2040 "hello there, how are you doing today",
2041 "what time is it right now",
2042 ] {
2043 let intent = resolve_text(text).intent();
2044 assert!(!intent.reading.domains.contains("live-data"), "{text}");
2045 }
2046 }
2047
2048 /// A question about an effect is a question: no effect is demanded.
2049 #[test]
2050 fn a_question_about_an_effect_demands_no_effect() {
2051 let intent = resolve_text("Did the email send?").intent();
2052 assert_eq!(intent.reading.act, Act::Answer);
2053 assert_eq!(intent.engagement.posture.stop, crate::StopProfile::Message);
2054 assert_ne!(intent.reading.stakes, Stakes::Irreversible);
2055 }
2056
2057 /// Pasted material is read as material: one question about a log is one
2058 /// part, whatever the log's lines say.
2059 #[test]
2060 fn a_pasted_log_is_material_not_parts() {
2061 let mut text = String::from("why is this service failing? here is the log:\n");
2062 for i in 0..300 {
2063 let verb = ["check", "update", "send", "delete", "deploy"][i % 5];
2064 text.push_str(&format!(
2065 "2026-09-26T10:{:02}:{:02}Z INFO worker {verb} job {i} for customer account\n",
2066 i / 60,
2067 i % 60
2068 ));
2069 }
2070 let intent = resolve_text(&text).intent();
2071 assert_eq!(intent.strands.len(), 1, "{}", intent.strands.len());
2072 assert_eq!(intent.reading.act, Act::Answer);
2073 assert_ne!(intent.reading.stakes, Stakes::Irreversible);
2074 assert!(intent.engagement.posture.note.is_none());
2075 }
2076
2077 /// Resolution is linear in the size of the request. A 50 KB paste took
2078 /// 105 s in a release build when every fold re-extracted the text.
2079 #[test]
2080 fn a_large_paste_resolves_quickly() {
2081 let mut text = String::from("analyze this data:\n");
2082 for i in 0..2_000 {
2083 text.push_str(&format!(
2084 "{i},{},{},north,widget-{}\n",
2085 i * 3,
2086 i % 7,
2087 i % 13
2088 ));
2089 }
2090 let started = std::time::Instant::now();
2091 let intent = resolve_text(&text).intent();
2092 assert!(
2093 started.elapsed() < std::time::Duration::from_secs(2),
2094 "{:?}",
2095 started.elapsed()
2096 );
2097 assert_eq!(intent.reading.act, Act::Analyze);
2098 }
2099
2100 /// Any number of real parts is supported; the note stays bounded.
2101 #[test]
2102 fn many_parts_are_all_read_and_the_note_stays_bounded() {
2103 let mut text = String::from("do these:\n");
2104 for i in 0..20 {
2105 text.push_str(&format!("{}. fix the parser case {i}\n", i + 1));
2106 }
2107 let intent = resolve_text(&text).intent();
2108 assert_eq!(intent.strands.len(), 20);
2109 let note = intent.engagement.posture.note.as_deref().unwrap();
2110 assert!(note.contains("20 parts"), "{note}");
2111 assert!(note.lines().count() <= 2 * LISTED_PARTS + 4, "{note}");
2112 // No part is labelled with the runtime's own act names.
2113 for act in Act::ALL {
2114 assert!(!note.contains(&format!(": {}", act.as_str())), "{note}");
2115 }
2116 }
2117
2118 /// A below-floor reading keeps what it *observed*: an attached image is a
2119 /// fact, and the ledger must not record a text-only turn.
2120 #[test]
2121 fn the_orienting_fallback_keeps_observed_modalities() {
2122 let attachments = vec![crate::Attachment {
2123 modality: Modality::Image,
2124 name: "x.png".into(),
2125 }];
2126 let mut req = request("zorble the frobnicator");
2127 req.attachments = &attachments;
2128 let config = ResolverConfig {
2129 provisional_confidence: 0.6,
2130 ..ResolverConfig::default()
2131 };
2132 let intent = resolve(&req, &Declared::default(), &Authority::default(), &config).intent();
2133 assert_eq!(intent.provenance.tier, Tier::General);
2134 assert!(intent.reading.input_modalities.contains(&Modality::Image));
2135 assert!(
2136 intent
2137 .engagement
2138 .limits
2139 .required_modalities
2140 .contains(&Modality::Image)
2141 );
2142 }
2143
2144 #[test]
2145 fn an_envelope_narrows_the_strands_it_covers() {
2146 let mut req = request("refactor the parser");
2147 req.turn_id = "turn";
2148 let intent = resolve(
2149 &req,
2150 &Declared::default(),
2151 &Authority::default(),
2152 &ResolverConfig::default(),
2153 )
2154 .intent();
2155 let envelope = Envelope {
2156 envelope_id: "env".into(),
2157 granted_by: "operator".into(),
2158 granted_at: now(),
2159 expires_at: None,
2160 spend_limit_usd: Some(2.0),
2161 path_scope: Vec::new(),
2162 tool_scope: Vec::new(),
2163 permission_ceiling: crate::PermissionCeiling::WorkspaceWrite,
2164 escalation: crate::Escalation::WaitIndefinitely,
2165 revoked_at: None,
2166 };
2167 let envelopes = BTreeMap::from([("turn.0".to_string(), envelope.clone())]);
2168 let narrowed = apply_envelopes(intent.clone(), &envelopes, Autonomy::Delegated, now());
2169 assert_eq!(
2170 narrowed.engagement.limits.permission_ceiling,
2171 crate::PermissionCeiling::WorkspaceWrite
2172 );
2173 assert_eq!(narrowed.engagement.limits.spend_ceiling_usd, Some(2.0));
2174 assert_eq!(narrowed.engagement.posture.hil, HilMode::Envelope);
2175 assert!(
2176 narrowed
2177 .engagement
2178 .limits
2179 .is_at_most(&intent.engagement.limits)
2180 );
2181
2182 // A revoked grant narrows nothing and grants nothing.
2183 let mut revoked = envelope;
2184 revoked.revoked_at = Some(now());
2185 let untouched = apply_envelopes(
2186 intent.clone(),
2187 &BTreeMap::from([("turn.0".to_string(), revoked)]),
2188 Autonomy::Delegated,
2189 now(),
2190 );
2191 assert_eq!(untouched, intent);
2192 }
2193}
2194

1599 ..Classification::default()
1600 }],
1601 "m",
1602 "d",
1603 &Authority::default(),
1604 &ResolverConfig::default(),
1605 false,
1606 );
1607 assert_eq!(after.provenance.tier, Tier::LocalModel);
1608 assert!(after.reading.domains.contains("web"));
1609 assert!(!after.reading.domains.contains("weather"));
1610 }
1611
1612 #[test]
1613 fn operate_is_never_assumed_cheap_and_governing_is_reversible() {
1614 assert_eq!(implied_stakes(Act::Operate), Stakes::Irreversible);
1615 assert_eq!(implied_stakes(Act::Govern), Stakes::Reversible);
1616 assert_eq!(implied_stakes(Act::Answer), Stakes::Inert);
1617 }
1618
1619 /// Below the acceptance bar the turn gets the orientation floor, never a
1620 /// guessed slice and never everything.
1621 #[test]
1622 fn provisional_readings_get_the_orientation_floor() {
1623 let config = ResolverConfig {
1624 accept_confidence: 0.99,
1625 provisional_confidence: 0.0,
1626 ..ResolverConfig::default()
1627 };
1628 let resolution = resolve(
1629 &request("explain the deploy script"),
1630 &Declared::default(),
1631 &Authority::default(),
1632 &config,
1633 );
1634 assert_eq!(
1635 resolution.peek().engagement.limits.required_domains,
1636 Engagement::orienting().limits.required_domains
1637 );
1638 }
1639
1640 #[test]
1641 fn a_confident_reading_does_slice() {
1642 let resolution = resolve_text("hello");
1643 assert!(
1644 !resolution
1645 .peek()
1646 .engagement
1647 .limits
1648 .required_domains
1649 .is_empty()
1650 );
1651 }
1652
1653 // ----------------------------------------------------------- strands ---
1654
1655 #[test]
1656 fn a_compound_request_becomes_ordered_strands_with_the_union_of_domains() {
1657 let intent = resolve_text("first explain the parser, then refactor it").intent();
1658 assert_eq!(intent.strands.len(), 2);
1659 assert_eq!(intent.strands[0].reading.act, Act::Answer);
1660 assert_eq!(intent.strands[1].reading.act, Act::Modify);
1661 assert_eq!(
1662 intent.strands[1].relation,
1663 StrandRelation::Sequential {
1664 after: intent.strands[0].strand_id.clone()
1665 }
1666 );
1667 // Composite: the consequential strand, widened by the other.
1668 assert_eq!(intent.reading.act, Act::Modify);
1669 assert!(intent.reading.alternate_acts.contains(&Act::Answer));
1670 // The slice covers both parts.
1671 let domains = &intent.engagement.limits.required_domains;
1672 assert!(domains.contains("live-data"), "answer's domains lost");
1673 assert!(domains.contains("code-exec"), "modify's domains lost");
1674 // And the model is told there are two parts, without the request
1675 // being quoted back at it.
1676 let note = intent.engagement.posture.note.as_deref().unwrap();
1677 assert!(note.contains("2 parts"), "{note}");
1678 assert!(note.contains("after part 1"), "{note}");
1679 for strand in &intent.strands {
1680 assert!(!note.contains(strand.text.trim()), "quoted: {note}");
1681 }
1682 }
1683
1684 /// Strand ids come from the host's turn id, so a thread — and the
1685 /// commitment keyed by it — never collides with another turn's.
1686 #[test]
1687 fn strand_ids_come_from_the_turn_id() {
1688 let mut req = request("fix the login bug. Also check whether the nightly job ran");
1689 req.turn_id = "0199a1b2-7c3d-7e4f-8a9b-0c1d2e3f4a5b";
1690 let intent = resolve(
1691 &req,
1692 &Declared::default(),
1693 &Authority::default(),
1694 &ResolverConfig::default(),
1695 )
1696 .intent();
1697 assert_eq!(
1698 intent.strands[0].strand_id,
1699 "0199a1b2-7c3d-7e4f-8a9b-0c1d2e3f4a5b.0"
1700 );
1701 assert_eq!(
1702 intent.strands[1].thread_id,
1703 "0199a1b2-7c3d-7e4f-8a9b-0c1d2e3f4a5b.1"
1704 );
1705 }
1706
1707 #[test]
1708 fn conversational_card_delivery_is_an_answer_not_workspace_authoring() {
1709 for text in [
1710 "Give me the latest India news and present it as a card",
1711 "What is the current weather in Delhi? Show it as a card",
1712 ] {
1713 let intent = resolve_text(text).intent();
1714 assert_eq!(intent.reading.act, Act::Answer, "{text}");
1715 assert!(
1716 intent
1717 .strands
1718 .iter()
1719 .all(|strand| strand.reading.act != Act::Author),
1720 "{text}: {:?}",
1721 intent.strands
1722 );
1723 assert!(intent.reading.domains.contains("live-data"), "{text}");
1724 }
1725 }
1726
1727 #[test]
1728 fn unrelated_strands_are_independent_threads() {
1729 let intent =
1730 resolve_text("fix the login bug. Also check whether the nightly job ran").intent();
1731 assert_eq!(intent.strands.len(), 2);
1732 assert_eq!(intent.strands[1].relation, StrandRelation::Independent);
1733 assert_ne!(intent.strands[0].thread_id, intent.strands[1].thread_id);
1734 assert!(matches!(intent.strands[0].lineage, Lineage::New));
1735 }
1736
1737 #[test]
1738 fn a_strand_continues_an_open_thread_it_points_at() {
1739 let mut req = request("now refactor it");
1740 req.history.turn_index = 2;
1741 req.history.open_threads = vec![ThreadFact {
1742 thread_id: "s0.0".into(),
1743 act: Act::Modify,
1744 domains: BTreeSet::new(),
1745 keywords: crate::strand::keywords("fix the parser"),
1746 }];
1747 let intent = resolve(
1748 &req,
1749 &Declared::default(),
1750 &Authority::default(),
1751 &ResolverConfig::default(),
1752 )
1753 .intent();
1754 assert_eq!(
1755 intent.strands[0].lineage,
1756 Lineage::Continues {
1757 thread_id: "s0.0".into()
1758 }
1759 );
1760 assert_eq!(intent.strands[0].thread_id, "s0.0");
1761 }
1762
1763 /// Corrections and replacements are never inferred from text, and a
1764 /// replacement starts a thread of its own.
1765 #[test]
1766 fn corrections_only_come_from_an_explicit_hint() {
1767 let thread = ThreadFact {
1768 thread_id: "s0.0".into(),
1769 act: Act::Modify,
1770 domains: BTreeSet::new(),
1771 keywords: crate::strand::keywords("refactor the parser"),
1772 };
1773 let mut req = request("actually refactor the parser to use a state machine instead");
1774 req.history.turn_index = 1;
1775 req.history.open_threads = vec![thread.clone()];
1776 let inferred = resolve(
1777 &req,
1778 &Declared::default(),
1779 &Authority::default(),
1780 &ResolverConfig::default(),
1781 )
1782 .intent();
1783 assert!(matches!(
1784 inferred.strands[0].lineage,
1785 Lineage::Continues { .. }
1786 ));
1787
1788 req.lineage_hint = Some(LineageHint::Replaces);
1789 let explicit = resolve(
1790 &req,
1791 &Declared::default(),
1792 &Authority::default(),
1793 &ResolverConfig::default(),
1794 )
1795 .intent();
1796 assert_eq!(
1797 explicit.strands[0].lineage,
1798 Lineage::Replaces {
1799 thread_id: "s0.0".into()
1800 }
1801 );
1802 assert_eq!(explicit.strands[0].thread_id, explicit.strands[0].strand_id);
1803 }
1804
1805 /// A greeting beside real work is context for it, not a part of its own.
1806 #[test]
1807 fn a_greeting_beside_real_work_is_not_a_part() {
1808 let intent = resolve_text("hi! then refactor the parser").intent();
1809 assert_eq!(intent.strands.len(), 1, "{:?}", intent.strands);
1810 assert_eq!(intent.reading.act, Act::Modify);
1811 assert!(intent.engagement.posture.note.is_none());
1812 }
1813
1814 #[test]
1815 fn the_strictest_strand_governs_authority() {
1816 let intent =
1817 resolve_text("summarise the changelog, then deploy the service to production").intent();
1818 assert_eq!(
1819 intent.engagement.limits.approval_ceiling,
1820 crate::ApprovalCeiling::Ask
1821 );
1822 assert_eq!(intent.reading.stakes, Stakes::Irreversible);
1823 assert_eq!(intent.engagement.posture.stop, crate::StopProfile::Effect);
1824 }
1825
1826 #[test]
1827 fn per_strand_classifications_apply_in_order() {
1828 let partial = resolve_text("first explain the parser, then refactor it").intent();
1829 let answer = apply_classification(
1830 partial,
1831 &[
1832 Classification {
1833 evidence: Some("cited".into()),
1834 confidence: Some(0.9),
1835 ..Classification::default()
1836 },
1837 Classification {
1838 horizon: Some("session".into()),
1839 confidence: Some(0.9),
1840 ..Classification::default()
1841 },
1842 ],
1843 "m",
1844 "d",
1845 &Authority::default(),
1846 &ResolverConfig::default(),
1847 false,
1848 );
1849 assert_eq!(answer.strands[0].reading.evidence, Evidence::Cited);
1850 assert_eq!(answer.strands[1].reading.horizon, Horizon::Session);
1851 assert_ne!(answer.strands[0].reading.horizon, Horizon::Session);
1852 }
1853
1854 /// A classifier that splits the request differently than the segmenter
1855 /// is still evidence: its objects fold on the cautious side and apply
1856 /// to every strand, never discarded.
1857 #[test]
1858 fn a_mismatched_classification_count_folds_cautiously() {
1859 let partial = resolve_text("zorble the frobnicator, then flimflam the widget").intent();
1860 assert_eq!(partial.strands.len(), 1);
1861 let answer = apply_classification(
1862 partial,
1863 &[
1864 Classification {
1865 act: Some("answer".into()),
1866 stakes: Some("inert".into()),
1867 confidence: Some(0.9),
1868 ..Classification::default()
1869 },
1870 Classification {
1871 act: Some("modify".into()),
1872 stakes: Some("costly".into()),
1873 evidence: Some("verified".into()),
1874 confidence: Some(0.6),
1875 ..Classification::default()
1876 },
1877 ],
1878 "m",
1879 "d",
1880 &Authority::default(),
1881 &ResolverConfig::default(),
1882 false,
1883 );
1884 assert_eq!(answer.provenance.tier, Tier::LocalModel);
1885 assert_eq!(answer.reading.act, Act::Modify);
1886 assert_eq!(answer.reading.stakes, Stakes::Costly);
1887 assert_eq!(answer.reading.evidence, Evidence::Verified);
1888 assert!((answer.reading.axis_confidence.act - 0.6).abs() < 1e-9);
1889 }
1890
1891 #[test]
1892 fn classifier_answers_parse_leniently() {
1893 let parsed = parse_classifications("```json\n[{\"act\":\"modify\"}]\n```").unwrap();
1894 assert_eq!(parsed.len(), 1);
1895 assert_eq!(parsed[0].act.as_deref(), Some("modify"));
1896 let parsed =
1897 parse_classifications("Sure: {\"act\":\"Answer\",\"confidence\":0.5} hope that helps")
1898 .unwrap();
1899 assert_eq!(parsed[0].act.as_deref(), Some("answer"));
1900 assert_eq!(parsed[0].confidence, Some(0.5));
1901 let parsed =
1902 parse_classifications("[{\"domains\":\"web, live-data\",\"confidence\":\"0.8\"}]")
1903 .unwrap();
1904 assert_eq!(parsed[0].domains, vec!["web", "live-data"]);
1905 assert_eq!(parsed[0].confidence, Some(0.8));
1906 assert!(parse_classifications("no json here").is_err());
1907 }
1908
1909 #[test]
1910 fn the_classifier_prompt_bounds_each_part() {
1911 let long = format!("explain {}", "the parser in great detail ".repeat(40));
1912 let intent = resolve_text(&long).intent();
1913 let prompt = classification_prompt(&intent);
1914 let part = prompt.lines().find(|line| line.starts_with("1. ")).unwrap();
1915 assert!(part.chars().count() <= PROMPT_PART_CHARS + 4, "{part}");
1916 assert!(classification_budget(1) >= 200);
1917 assert!(classification_budget(50) <= 1_600);
1918 }
1919
1920 /// Regression corpus for the lexical false positives two reviews found.
1921 #[test]
1922 fn everyday_requests_do_not_grow_horizons_stakes_or_evidence() {
1923 let cases: &[(&str, Horizon, Stakes, Evidence)] = &[
1924 (
1925 "fix the authentication bug in the login handler",
1926 Horizon::Turn,
1927 Stakes::Reversible,
1928 Evidence::None,
1929 ),
1930 (
1931 "wait until the build finishes and tell me",
1932 Horizon::Turn,
1933 Stakes::Inert,
1934 Evidence::None,
1935 ),
1936 (
1937 "where does this config live",
1938 Horizon::Turn,
1939 Stakes::Inert,
1940 Evidence::None,
1941 ),
1942 (
1943 "explain the customer model in this codebase",
1944 Horizon::Turn,
1945 Stakes::Inert,
1946 Evidence::None,
1947 ),
1948 (
1949 "how does our production deploy work?",
1950 Horizon::Turn,
1951 Stakes::Inert,
1952 Evidence::None,
1953 ),
1954 (
1955 "look at the source code for the parser",
1956 Horizon::Turn,
1957 Stakes::Inert,
1958 Evidence::None,
1959 ),
1960 (
1961 "rename the Customer struct to Client",
1962 Horizon::Turn,
1963 Stakes::Reversible,
1964 Evidence::None,
1965 ),
1966 (
1967 "fix the payment form validation",
1968 Horizon::Turn,
1969 Stakes::Reversible,
1970 Evidence::None,
1971 ),
1972 (
1973 "remember that I prefer tabs over spaces",
1974 Horizon::Turn,
1975 Stakes::Reversible,
1976 Evidence::None,
1977 ),
1978 (
1979 "what happens whenever I press ctrl-c in the REPL?",
1980 Horizon::Turn,
1981 Stakes::Inert,
1982 Evidence::None,
1983 ),
1984 (
1985 "explain step by step how the borrow checker works",
1986 Horizon::Turn,
1987 Stakes::Inert,
1988 Evidence::None,
1989 ),
1990 (
1991 "write a poem about the sea and make sure it rhymes",
1992 Horizon::Turn,
1993 Stakes::Reversible,
1994 Evidence::None,
1995 ),
1996 ];
1997 for (text, horizon, stakes, evidence) in cases {
1998 let intent = resolve_text(text).intent();
1999 assert_eq!(intent.reading.horizon, *horizon, "{text}");
2000 assert_eq!(intent.reading.stakes, *stakes, "{text}");
2001 assert_eq!(intent.reading.evidence, *evidence, "{text}");
2002 assert!(!intent.engagement.posture.open_commitment, "{text}");
2003 assert_ne!(
2004 intent.engagement.limits.approval_ceiling,
2005 crate::ApprovalCeiling::Ask,
2006 "{text}"
2007 );
2008 }
2009 // A recurrence adjective names a thing, not a schedule.
2010 let adjective = resolve_text("check whether the nightly job ran").intent();
2011 assert_ne!(adjective.reading.horizon, Horizon::Durable);
2012 assert!(!adjective.engagement.posture.open_commitment);
2013 let adverb = resolve_text("check the cloud bill nightly and alert me").intent();
2014 assert_eq!(adverb.reading.horizon, Horizon::Durable);
2015 // And the ones that should still fire, still do.
2016 let deploy = resolve_text("deploy the service to production").intent();
2017 assert_eq!(deploy.reading.stakes, Stakes::Irreversible);
2018 let nightly = resolve_text("check the cloud bill every day and alert me").intent();
2019 assert_eq!(nightly.reading.horizon, Horizon::Durable);
2020 assert!(nightly.engagement.posture.open_commitment);
2021 let cited = resolve_text("summarise the paper and cite your sources").intent();
2022 assert_eq!(cited.reading.evidence, Evidence::Cited);
2023 }
2024
2025 /// Temporal words ask for a live value only beside a request for a fact.
2026 #[test]
2027 fn live_data_follows_a_request_for_a_fact() {
2028 for text in [
2029 "what is the current price of copper",
2030 "what's the weather in Delhi today",
2031 "give me the latest headlines",
2032 ] {
2033 let intent = resolve_text(text).intent();
2034 assert!(intent.reading.domains.contains("live-data"), "{text}");
2035 }
2036 for text in [
2037 "Refactor the current implementation of the parser to use a state machine",
2038 "update the README to reflect the latest changes",
2039 "fix the live reload bug in the dev server",
2040 "hello there, how are you doing today",
2041 "what time is it right now",
2042 ] {
2043 let intent = resolve_text(text).intent();
2044 assert!(!intent.reading.domains.contains("live-data"), "{text}");
2045 }
2046 }
2047
2048 /// A question about an effect is a question: no effect is demanded.
2049 #[test]
2050 fn a_question_about_an_effect_demands_no_effect() {
2051 let intent = resolve_text("Did the email send?").intent();
2052 assert_eq!(intent.reading.act, Act::Answer);
2053 assert_eq!(intent.engagement.posture.stop, crate::StopProfile::Message);
2054 assert_ne!(intent.reading.stakes, Stakes::Irreversible);
2055 }
2056
2057 /// Pasted material is read as material: one question about a log is one
2058 /// part, whatever the log's lines say.
2059 #[test]
2060 fn a_pasted_log_is_material_not_parts() {
2061 let mut text = String::from("why is this service failing? here is the log:\n");
2062 for i in 0..300 {
2063 let verb = ["check", "update", "send", "delete", "deploy"][i % 5];
2064 text.push_str(&format!(
2065 "2026-09-26T10:{:02}:{:02}Z INFO worker {verb} job {i} for customer account\n",
2066 i / 60,
2067 i % 60
2068 ));
2069 }
2070 let intent = resolve_text(&text).intent();
2071 assert_eq!(intent.strands.len(), 1, "{}", intent.strands.len());
2072 assert_eq!(intent.reading.act, Act::Answer);
2073 assert_ne!(intent.reading.stakes, Stakes::Irreversible);
2074 assert!(intent.engagement.posture.note.is_none());
2075 }
2076
2077 /// Resolution is linear in the size of the request. A 50 KB paste took
2078 /// 105 s in a release build when every fold re-extracted the text.
2079 #[test]
2080 fn a_large_paste_resolves_quickly() {
2081 let mut text = String::from("analyze this data:\n");
2082 for i in 0..2_000 {
2083 text.push_str(&format!(
2084 "{i},{},{},north,widget-{}\n",
2085 i * 3,
2086 i % 7,
2087 i % 13
2088 ));
2089 }
2090 let started = std::time::Instant::now();
2091 let intent = resolve_text(&text).intent();
2092 assert!(
2093 started.elapsed() < std::time::Duration::from_secs(2),
2094 "{:?}",
2095 started.elapsed()
2096 );
2097 assert_eq!(intent.reading.act, Act::Analyze);
2098 }
2099
2100 /// Any number of real parts is supported; the note stays bounded.
2101 #[test]
2102 fn many_parts_are_all_read_and_the_note_stays_bounded() {
2103 let mut text = String::from("do these:\n");
2104 for i in 0..20 {
2105 text.push_str(&format!("{}. fix the parser case {i}\n", i + 1));
2106 }
2107 let intent = resolve_text(&text).intent();
2108 assert_eq!(intent.strands.len(), 20);
2109 let note = intent.engagement.posture.note.as_deref().unwrap();
2110 assert!(note.contains("20 parts"), "{note}");
2111 assert!(note.lines().count() <= 2 * LISTED_PARTS + 4, "{note}");
2112 // No part is labelled with the runtime's own act names.
2113 for act in Act::ALL {
2114 assert!(!note.contains(&format!(": {}", act.as_str())), "{note}");
2115 }
2116 }
2117
2118 /// A below-floor reading keeps what it *observed*: an attached image is a
2119 /// fact, and the ledger must not record a text-only turn.
2120 #[test]
2121 fn the_orienting_fallback_keeps_observed_modalities() {
2122 let attachments = vec![crate::Attachment {
2123 modality: Modality::Image,
2124 name: "x.png".into(),
2125 }];
2126 let mut req = request("zorble the frobnicator");
2127 req.attachments = &attachments;
2128 let config = ResolverConfig {
2129 provisional_confidence: 0.6,
2130 ..ResolverConfig::default()
2131 };
2132 let intent = resolve(&req, &Declared::default(), &Authority::default(), &config).intent();
2133 assert_eq!(intent.provenance.tier, Tier::General);
2134 assert!(intent.reading.input_modalities.contains(&Modality::Image));
2135 assert!(
2136 intent
2137 .engagement
2138 .limits
2139 .required_modalities
2140 .contains(&Modality::Image)
2141 );
2142 }
2143
2144 #[test]
2145 fn an_envelope_narrows_the_strands_it_covers() {
2146 let mut req = request("refactor the parser");
2147 req.turn_id = "turn";
2148 let intent = resolve(
2149 &req,
2150 &Declared::default(),
2151 &Authority::default(),
2152 &ResolverConfig::default(),
2153 )
2154 .intent();
2155 let envelope = Envelope {
2156 envelope_id: "env".into(),
2157 granted_by: "operator".into(),
2158 granted_at: now(),
2159 expires_at: None,
2160 spend_limit_usd: Some(2.0),
2161 path_scope: Vec::new(),
2162 tool_scope: Vec::new(),
2163 permission_ceiling: crate::PermissionCeiling::WorkspaceWrite,
2164 escalation: crate::Escalation::WaitIndefinitely,
2165 revoked_at: None,
2166 };
2167 let envelopes = BTreeMap::from([("turn.0".to_string(), envelope.clone())]);
2168 let narrowed = apply_envelopes(intent.clone(), &envelopes, Autonomy::Delegated, now());
2169 assert_eq!(
2170 narrowed.engagement.limits.permission_ceiling,
2171 crate::PermissionCeiling::WorkspaceWrite
2172 );
2173 assert_eq!(narrowed.engagement.limits.spend_ceiling_usd, Some(2.0));
2174 assert_eq!(narrowed.engagement.posture.hil, HilMode::Envelope);
2175 assert!(
2176 narrowed
2177 .engagement
2178 .limits
2179 .is_at_most(&intent.engagement.limits)
2180 );
2181
2182 // A revoked grant narrows nothing and grants nothing.
2183 let mut revoked = envelope;
2184 revoked.revoked_at = Some(now());
2185 let untouched = apply_envelopes(
2186 intent.clone(),
2187 &BTreeMap::from([("turn.0".to_string(), revoked)]),
2188 Autonomy::Delegated,
2189 now(),
2190 );
2191 assert_eq!(untouched, intent);
2192 }
2193}
2194

Indexing the workspace…