1001. 1001 };
1002. 1002 let narrow = Limits {
1003. 1003 required_domains: crate::limits::DomainSet::only(["web"]),
1004. 1004 ..Limits::unrestricted()
1005. 1005 };
1006. 1006 let met = wide.meet(&narrow);
1007. 1007 assert_eq!(
1008. 1008 met.required_domains,
1009. 1009 crate::limits::DomainSet::only(["web"])
1010. 1010 );
1011. 1011 assert!(met.is_at_most(&wide));
1012. 1012 assert!(!wide.is_at_most(&narrow), "widening must not validate");
1013. 1013 }
1014. 1014
1015. 1015 #[test]
1016. 1016 fn durable_work_is_managed_opens_a_commitment_and_renders_full_context() {
1017. 1017 let r = reading(
1018. 1018 Act::Modify,
1019. 1019 Horizon::Durable,
1020. 1020 Stakes::Reversible,
1021. 1021 Evidence::Verified,
1022. 1022 );
1023. 1023 let engagement = derive(&r, &Authority::default(), true);
1024. 1024 assert!(engagement.posture.managed);
1025. 1025 assert!(engagement.posture.open_commitment);
1026. 1026 assert_eq!(engagement.posture.context, ContextProfile::Full);
1027. 1027 assert_eq!(engagement.posture.stop, StopProfile::Verification);
1028. 1028 assert_eq!(
1029. 1029 engagement.limits.min_satisfaction,
1030. 1030 crate::Satisfaction::Observed
1031. 1031 );
1032. 1032 }
1033. 1033
1034. 1034 #[test]
1035. 1035 fn audited_work_cannot_be_closed_by_the_model_alone() {
1036. 1036 let r = reading(
1037. 1037 Act::Modify,
1038. 1038 Horizon::Session,
1039. 1039 Stakes::Reversible,
1040. 1040 Evidence::Audited,
1041. 1041 );
1042. 1042 let engagement = derive(&r, &Authority::default(), true);
1043. 1043 assert_eq!(
1044. 1044 engagement.limits.min_satisfaction,
1045. 1045 crate::Satisfaction::Attested
1046. 1046 );
1047. 1047 assert!(!crate::Satisfaction::Asserted.satisfies(engagement.limits.min_satisfaction));
1048. 1048 assert!(!crate::Satisfaction::Cited.satisfies(engagement.limits.min_satisfaction));
1049. 1049 }
1050. 1050
1051. 1051 #[test]
1052. 1052 fn low_stakes_ambiguity_states_an_assumption_and_high_stakes_asks() {
1053. 1053 let mut low = reading(Act::Answer, Horizon::Turn, Stakes::Inert, Evidence::None);
1054. 1054 low.clarity = Clarity::Ambiguous;
1055. 1055 assert_eq!(
1056. 1056 derive(&low, &Authority::default(), true).posture.clarify,
1057. 1057 ClarifyPolicy::StateAssumption
1058. 1058 );
1059. 1059
1060. 1060 let mut high = reading(
1061. 1061 Act::Operate,
1062. 1062 Horizon::Turn,
1063. 1063 Stakes::Irreversible,
1064. 1064 Evidence::None,
1065. 1065 );
1066. 1066 high.clarity = Clarity::Ambiguous;
1067. 1067 assert_eq!(
1068. 1068 derive(&high, &Authority::default(), true).posture.clarify,
1069. 1069 ClarifyPolicy::Ask
1070. 1070 );
1071. 1071 }
1072. 1072
1073. 1073 #[test]
1074. 1074 fn unattended_durable_costly_work_defers_rather_than_interrupting() {
1075. 1075 let r = reading(
1076. 1076 Act::Operate,
1077. 1077 Horizon::Durable,
1078. 1078 Stakes::Costly,
1079. 1079 Evidence::None,
1080. 1080 );
1081. 1081 let authority = Authority {
1082. 1082 autonomy: Autonomy::Delegated,
1083. 1083 attendance: Attendance::Unattended,
1084. 1084 };
1085. 1085 let engagement = derive(&r, &authority, true);
1086. 1086 assert_eq!(engagement.posture.hil, HilMode::Defer);
1087. 1087 assert_eq!(engagement.posture.gate_fallback, GateFallback::Defer);
1088. 1088 }
1089. 1089
1090. 1090 #[test]
1091. 1091 fn unattended_work_rolls_up_instead_of_pinging() {
1092. 1092 let mut r = reading(Act::Verify, Horizon::Durable, Stakes::Inert, Evidence::None);
1093. 1093 r.attendance = Attendance::Unattended;
1094. 1094 let delivery = derive(&r, &Authority::default(), true).posture.delivery;
1095. 1095 assert_eq!(delivery.cadence, Cadence::Digest);
1096. 1096 assert_eq!(delivery.urgency, Urgency::Quiet);
1097. 1097 }
1098. 1098
1099. 1099 #[test]
1100. 1100 fn irreversible_work_always_interrupts_and_says_so_in_the_prompt() {
1101. 1101 let r = reading(
1102. 1102 Act::Operate,
1103. 1103 Horizon::Turn,
1104. 1104 Stakes::Irreversible,
1105. 1105 Evidence::None,
1106. 1106 );
1107. 1107 let engagement = derive(&r, &Authority::default(), true);
1108. 1108 assert_eq!(engagement.posture.hil, HilMode::Interrupt);
1109. 1109 assert_eq!(engagement.posture.delivery.urgency, Urgency::Interrupt);
1110. 1110 assert!(
1111. 1111 engagement
1112. 1112 .posture
1113. 1113 .note
1114. 1114 .as_deref()
1115. 1115 .is_some_and(|n| n.contains("cannot be undone"))
1116. 1116 );
1117. 1117 }
1118. 1118
1119. 1119 #[test]
1120. 1120 fn demand_is_populated_rather_than_left_at_zero() {
1121. 1121 let r = reading(
1122. 1122 Act::Analyze,
1123. 1123 Horizon::Session,
1124. 1124 Stakes::Inert,
1125. 1125 Evidence::Cited,
1126. 1126 );
1127. 1127 let demand = derive(&r, &Authority::default(), true).posture.demand;
1128. 1128 assert!(demand.reasoning_required);
1129. 1129 assert!(demand.evidence_required);
1130. 1130 }
1131. 1131
1132. 1132 /// A reading whose contenders include an effectful act must checkpoint;
1133. 1133 /// the stop rule follows the primary act, and a compound request with a
1134. 1134 /// genuinely effectful part carries it as a strand of its own.
1135. 1135 #[test]
1136. 1136 fn any_effectful_contender_forces_a_checkpoint_but_not_an_effect_stop() {
1137. 1137 let mut r = reading(
1138. 1138 Act::Verify,
1139. 1139 Horizon::Session,
1140. 1140 Stakes::Reversible,
1141. 1141 Evidence::None,
1142. 1142 );
1143. 1143 r.alternate_acts.insert(Act::Modify);
1144. 1144 let engagement = derive(&r, &Authority::default(), true);
1145. 1145 assert!(engagement.posture.checkpoint_before_effect);
1146. 1146 assert_eq!(engagement.posture.stop, StopProfile::Inspection);
1147. 1147
1148. 1148 // And a reading with no effectful act does neither.
1149. 1149 let inert = reading(
1150. 1150 Act::Answer,
1151. 1151 Horizon::Turn,
1152. 1152 Stakes::Reversible,
1153. 1153 Evidence::None,
1154. 1154 );
1155. 1155 let engagement = derive(&inert, &Authority::default(), true);
1156. 1156 assert!(!engagement.posture.checkpoint_before_effect);
1157. 1157 assert_eq!(engagement.posture.stop, StopProfile::Message);
1158. 1158 }
1159. 1159
1160. 1160 #[test]
1161. 1161 fn meet_of_two_engagements_never_widens_either() {
1162. 1162 let a = derive(
1163. 1163 &reading(
1164. 1164 Act::Modify,
1165. 1165 Horizon::Session,
1166. 1166 Stakes::Costly,
1167. 1167 Evidence::Verified,
1168. 1168 ),
1169. 1169 &Authority::default(),
1170. 1170 true,
1171. 1171 );
1172. 1172 let b = derive(
1173. 1173 &reading(Act::Answer, Horizon::Turn, Stakes::Inert, Evidence::None),
1174. 1174 &Authority::default(),
1175. 1175 true,
1176. 1176 );
1177. 1177 let met = a.meet(&b);
1178. 1178 assert!(met.limits.is_at_most(&a.limits));
1179. 1179 assert!(met.limits.is_at_most(&b.limits));
1180. 1180 }
1181. 1181}
1182. 1182